Skip to main content
The Coding Agent is pre.dev’s flagship. Point it at a prompt, a template, or an existing GitHub repo — it plans the architecture first, then builds against that plan autonomously, verifying each task, opening real PRs, and deploying a live preview. You stay in the loop as a reviewer, not a typist.

Build your first project

Sign up, describe an app, hit Build on Autopilot. Minutes to a deployed product.

​
How it works

1. Plan

One prompt → a full structured spec: stack, milestones, user stories, acceptance criteria. Fast Spec in ~1 minute, Deep Spec in ~3–5.

2. Build

Agents work the roadmap in isolated sandboxes — for hours if the roadmap calls for it. Each task verifies itself (types, lint, tests, browser) before it ships.

3. Ship

Real PRs land on feature branches in your GitHub. A live preview runs the whole time; hosting and custom domains are built in.

​
Built for long-horizon work

Most coding agents are great for twenty minutes. pre.dev is built for the build that takes all day:

Effort levels

Dial how deep each sprint goes with /effort — low for a fast direct pass, medium for a task-list loop, high for the full research → code → verify pipeline. Or leave it on auto (the default).

Your models, per phase

Pin a different model to each phase of the work — chat, research, coding, acceptance — with /model, or flip on Pro Mode for the strongest model everywhere.

Sessions: fork & merge

Every session is an isolated branch of your project. Fork to try something risky, work several in parallel, merge back what works. Context persists across all of them.

Parallel agents

Big sprints fan out to multiple agents at once. Watch each branch’s objective, progress, live diffs, and conclusion in real time.

​
What you get

Working integrations, not stubs

Stripe, Supabase, Clerk, OpenAI, Linear, Slack — any service you’ve connected. Real keys, real endpoints, real data. No YOUR_API_KEY placeholders.

Verified code, not vibes

Every PR passes types, lint, tests, and browser verification — with before/after screenshots as evidence — before it’s opened.

Progress you can watch

Live timeline of the agent’s work — its streaming thoughts, which file it’s editing, which test just passed, which PR just opened.

Your choice of control

Pick a sprint mode — Autopilot for the whole roadmap, Next Task to review each PR, custom sprints for anything else, or plain chat — and an effort level for how deep each sprint goes.
Work from the web workspace — a terminal-style chat with live Plan, Code, and Preview views — or from the pre.dev CLI with the same slash commands and controls. See The Workspace.

​
Extend what the agent can do

Agents are only as capable as the services they can reach. Connect your stack once — every project inherits it.

OAuth Connectors

Sign in once (GitHub, Linear, Slack, Notion, etc.) so the agent can read and write on your behalf.

API Keys & Secrets

Store provider keys (Stripe, OpenAI, Twilio) once and inject them into every build.

MCP Servers

Attach any MCP server to expand the tool set the agent can call at build time.

Agent Skills

Custom instructions injected into every prompt — your conventions, your constraints, your voice.

​
Who it’s for

Founders & PMs

Ship without writing code. Stay focused on product direction while the agent handles implementation.

Solo developers

Compress weeks of boilerplate into hours. Spend your time on the parts that actually need you.

Teams

Queue work as specs and review PRs — the agent handles the rote 70%, you focus on the 30% that matters.

Agencies

Standardize delivery across client projects. Consistent stacks, consistent quality, faster turnaround.