Gitship

Turn any GitHub repository into a production-ready Docker container instantly with AI-powered Dockerfile generation.

Comment

Inspiration

Developers often struggle with writing optimized, production-ready Dockerfiles. Figuring out the perfect base image, dependency management commands, and security best practices can be tedious and prone to error. For the OpenAI Build Week, we wanted to completely eliminate this friction and create a tool that does the heavy lifting for you—generating perfect Dockerfiles automatically from nothing but a GitHub URL.

What it does

Gitship is an AI-powered web application that takes any public GitHub repository link, deeply analyzes the entire codebase structure, and generates a custom, highly optimized Dockerfile.

Not only does it stream the generation process live to the user, but it also automatically detects the tech stack (Python, Node.js, Go, etc.) and even suggests a docker-compose.yml file for multi-container setups. You can even pass it custom instructions like "Use Alpine Linux" or "Include PostgreSQL".

How we built it

We built the backend using Python and FastAPI, heavily utilizing WebSockets to stream real-time responses to the UI.

Here is the flow:

  1. When a user submits a URL, the backend temporarily clones the repository locally.
  2. It uses gitingest to create a dense, token-optimized text summary of the codebase and file tree.
  3. This context is passed to Groq's API (running Llama models) with a highly specialized prompt.
  4. The generated infrastructure code is streamed live back to the frontend.

The frontend is built with vanilla HTML/CSS and TailwindCSS via Jinja2 templates. We integrated the Monaco Editor (the engine behind VS Code) to display the generated code with syntax highlighting. Throughout our development, we also used GPT-5.6 and Codex for architectural planning, debugging, and backend scaffolding.

Challenges we ran into

Handling large repositories was tricky. We had to ensure we extracted the relevant dependency files (package.json, requirements.txt, etc.) without blowing past the LLM's context window. Additionally, maintaining a stable WebSocket connection to stream the AI's response character-by-character required careful asynchronous state management in FastAPI to ensure the UI updated perfectly without dropping chunks.

Accomplishments that we're proud of

We are incredibly proud of the absolute speed of Gitship. By utilizing Groq's API, the Dockerfiles are generated almost instantaneously. We also managed to build a very clean, responsive, and intuitive UI that feels like a premium developer tool right out of the box.

What we learned

We significantly deepened our understanding of asynchronous Python and WebSocket architecture. We also learned advanced prompt engineering techniques specifically tailored for infrastructure-as-code (IaC) generation, ensuring the AI outputs valid Docker syntax rather than conversational text.

What's next for Gitship

We plan to build a native GitHub App integration so Gitship can automatically open a Pull Request with the generated Dockerfile directly in the user's repository. We also plan to integrate one-click deployments to cloud providers right from our dashboard.

Built With

Share this project:

Updates