Ditto Code: Your AI Software Engineer

What if you could describe a web app in plain English and have it live on the internet five minutes later?

That’s Ditto Code. You type a message, an AI agent writes the code, installs the dependencies, runs the tests, and deploys it to a public URL. You watch every step in real time. No terminal. No Git commands. No deployment pipeline. No coding experience required.

Today, Ditto Code ships with GitHub integration, two project types, real-time event streaming, and a roadmap that’s building toward something much bigger: the ability to run an entire company from Ditto.

How It Works

The whole system fits into five steps, and you only do the first one.

1. You describe what you want

Open Ditto and type something like:

Build me a portfolio website with a dark theme,
project showcase section, and a contact form.

Or if you have GitHub connected:

Please refactor the auth module in @myorg/backend
to use JWT tokens instead of session cookies.

That’s it. That’s your entire contribution to the deployment pipeline.

2. Ditto understands your intent

Behind the scenes, a Gemini Flash Lite model analyzes your request and makes two decisions:

• Project type: Is this a new deployable app (type=app) or work on an existing codebase (type=code)?
• Project identity: Should this create a new project or continue an existing one?

If you mentioned a GitHub repo with @owner/repo, the system skips the classifier entirely and creates a deterministic code project.

3. An agent spins up

Ditto dispatches your task to a dedicated cloud environment: 4 CPUs, 8 GiB of memory, 30 minutes of runtime, running OpenHands, an open-source AI coding agent. The agent has access to:

• A full Linux environment with Node.js, Python, and common build tools
• Chromium for browsing documentation and testing
• Your Ditto memory via MCP (so it knows your preferences and past projects)
• Authenticated GitHub access (if connected) with gh CLI for PRs and issues

4. You watch it work

This is where Ditto Code is fundamentally different from “vibe coding” tools that show you a spinner and a result. The Agent Tasks UI streams every action in real time:

• Terminal: npm install, npm run build, test outputs
• Write: Every file the agent creates or modifies
• Think: The agent’s reasoning about design decisions
• Browse: Documentation lookups and web research
• Deploy: The final deployment step with your live URL

You can see the agent’s token usage, cost, and runtime at a glance. If something goes wrong, you can stop the job and redirect.

5. Your app goes live

For type=app projects, the agent’s output is automatically deployed to Google Cloud Run. You get a public URL within minutes. The source code is saved as Ditto artifacts, so you can iterate, fork, or hand it off to a developer later.

For type=code projects, the agent clones your repos, makes the changes, commits them, and can open pull requests directly on GitHub.

GitHub Integration: @mention Your Repos

The latest addition to Ditto Code is deep GitHub integration through the Ditto Code GitHub App.

Connect in seconds

1. Go to Settings > Apps in Ditto
2. Click Connect GitHub (OAuth popup, same flow as Google)
3. Install the Ditto Code GitHub App on your personal account or organization
4. Done. Your repos are now accessible from the chat.

@mention any repo

Once connected, type @ in the message composer and a fuzzy-search popover appears with all your accessible repositories. Select one (or several) and they become part of your prompt. The @owner/repo mention renders as a clickable badge in the chat, linking directly to the GitHub page.

What happens behind the scenes

When you mention a repo and Ditto dispatches an agent job:

• The backend generates a short-lived installation access token using the GitHub App’s RSA private key
• The runner authenticates via git config --global url."https://x-access-token:TOKEN@github.com/".insteadOf (tokens never appear in clone URLs)
• GH_TOKEN and GITHUB_TOKEN environment variables are set for gh CLI access
• The agent can read code, write code, commit changes, open PRs, and interact with issues
• All tokens are encrypted at rest with AES-256-GCM

Permissions

The Ditto Code GitHub App requests only what it needs:

Permission	Level	Why
Contents	Read & Write	Clone repos, push commits
Pull requests	Read & Write	Open and update PRs
Issues	Read & Write	Read context, create issues
Metadata	Read	List repos, branches
Commit statuses	Read	Check CI status
Emails	Read	Identify the GitHub account

You can revoke access at any time from Settings > Apps.

Two Project Types

Ditto Code supports two distinct modes, and the system picks the right one automatically.

App Projects (type=app)

For when you want a deployable web application.

• Ditto scaffolds a Flask + HTML template
• The agent writes your app, installs dependencies, tests it
• On completion, the workspace is packaged into a Docker container and deployed to Cloud Run
• You get a live public URL immediately
• No DNS, no Dockerfile, no CI/CD pipeline to configure

Example prompts:

• “Build me a recipe organizer with search and categories”
• “Make a dashboard that shows real-time crypto prices”
• “Create a landing page for my consulting business”

Code Projects (type=code)

For when you want to work on existing repositories.

• Ditto clones your GitHub repos (depth=50 for speed)
• The agent reads the codebase, understands the structure, and makes targeted changes
• Changes are committed with clear messages
• The agent can open PRs directly
• No deployment (the repo has its own CI/CD)

Example prompts:

• “Add rate limiting to the API endpoints in @myorg/backend”
• “Write unit tests for the auth module in @myorg/frontend”
• “Refactor the database queries to use connection pooling”

What This Means Today

Right now, someone with zero coding experience can:

1. Open Ditto
2. Describe a web app in plain English
3. Watch an AI agent build it in real time
4. Get a live URL they can share with anyone

That’s not a demo. That’s not a prototype. It’s a production deployment on Google Cloud Run with a real URL.

Every week, we’re expanding what “describe what you want” can produce. Today it’s single-page web apps and code changes. The trajectory is toward full businesses running on Ditto.

The Roadmap: Running a Company from Ditto

Ditto Code as it exists today is the foundation. Here’s what’s coming:

Authentication & User Management

Your deployed apps will support user login out of the box. OAuth providers (Google, GitHub), email/password, magic links. Tell Ditto “add user authentication to my app” and it wires up the entire auth flow, including protected routes and session management.

Persistent Databases

Every project gets its own database. PostgreSQL for relational data, SQLite for lightweight use cases. Your apps will persist data between sessions, handle migrations, and back up automatically. Say “add a database to store user profiles” and Ditto sets up the schema, ORM, and CRUD endpoints.

Heartbeats: Scheduled & Event-Driven Agents

Spawn an agent job on a schedule or in response to an event. “Check my API uptime every 5 minutes and alert me on Slack if it’s down.” “Every Monday morning, generate a summary report from last week’s data.” Heartbeats turn Ditto from a tool you use into an assistant that works while you sleep.

Custom Domains with DNS Registration

Point your own domain at your Ditto-deployed app. We’ll handle DNS configuration, SSL certificates, and routing. Go from “build me a landing page” to “deploy it at mycoolstartup.com” in one conversation.

Full-Stack Applications

Frontend, backend, API, and database, all generated and deployed together. React or SolidJS frontends talking to Go or Python backends, with proper API contracts, error handling, and production configuration. One conversation, full stack.

Multi-Harness Execution

Today, Ditto Code runs on OpenHands. Soon, you’ll be able to choose your execution engine:

• Cursor Cloud SDK (Composer 2.5): Bring your own Cursor API key for cloud-based code generation with 79.8% SWE-Bench Multilingual accuracy
• Claude Code: Anthropic’s coding agent for complex refactoring and architecture work
• Antigravity: Specialized harness for full-stack app generation
• OpenHands (default): The open-source foundation that works today

Each harness has different strengths. Ditto picks the best one for the job, or you choose.

The Bigger Picture

The tools to build software have been getting more accessible for decades. First we got higher-level languages. Then frameworks. Then no-code builders. Each step lowered the bar, but you still needed to understand the concepts underneath.

Ditto Code removes that requirement entirely. You don’t need to know what a framework is. You don’t need to know what deployment means. You don’t need to know what a database is. You describe the outcome you want, and a system that does understand all of those things builds it for you, transparently, in real time, with full source code you own.

This isn’t about replacing developers. It’s about giving everyone else the same superpower. The person with the business idea who can’t afford a dev team. The designer who wants to prototype without waiting for engineering. The researcher who needs a data dashboard but doesn’t want to learn React. The founder who wants to move at the speed of thought.

We ship improvements to Ditto Code every week. If you want to try it, open Ditto and describe what you want to build.

---

Questions or feedback? Reach us at support@heyditto.ai