Why DevSpec

DevSpec is where your team, your knowledge and your agents build software together, made for AI-native development from the ground up.

This page explains why DevSpec exists, the problems it solves for teams building software with AI, and how we think about human judgment, shared memory and control. If you want a plain-English tour of all the parts of DevSpec and how they fit together, read What is DevSpec.

A realistic way for real teams to build with AI

Most AI software tools today push teams into one of three corners:

• One-shot cloud app builders promise that anyone can build an app from a prompt with no developers involved. That feels magical for a weekend prototype, right up until a real business has to run on it. Non-technical people quickly end up out of their depth on architecture, security and data, with no clear way for an engineer to step in, review what was built or take over safely.
• Developer-only coding tools go the other way. They stay inside the terminal and the pull request, with at best a one-way bridge where someone drops a request into chat and hopes a developer translates it. Product people, founders, domain experts and clients are still shut out of the actual building loop, and every small change still waits on a game of telephone.
• Autonomous multi-agent experiments hand the keys to a swarm of bots and hope for the best. They burn through usage while drifting further from what the team actually wanted, leaving humans to clean up code nobody understands.

DevSpec is the practical fourth way: a shared workspace where developers, non-technical teammates and coding agents work together on real production software, with clear guardrails around who can change what and how work gets proved before it counts as done.

Ideas, judgment and conversation are the highest-leverage work

Be honest about what AI is good at and what it cannot do. AI is not genuinely creative, and it does not know your business, your customers, the trade-offs behind your roadmap or what happened in a customer call twenty minutes ago. Left to itself, an AI agent is also a sycophant: it flatters whoever is typing at it right now, agrees that their latest idea is brilliant, and happily rewrites yesterday's architecture to match.

What AI is extraordinary at is exploring options against your real codebase, surfacing trade-offs, and doing the heavy lifting of writing and checking code once people have decided what matters.

When DevSpec puts shared project context and role-based guardrails around your agents, the bottleneck shifts completely. Nobody needs to spend hours writing specs by hand, grooming a separate issue tracker, or asking an engineer to translate a product question into a ticket. The single highest-leverage thing your team can do is get into a session, talk ideas through together, challenge assumptions with Dev (DevSpec's assistant in every session) and your agents in the room, and make clear decisions.

Non-technical teammates are no longer stuck on the sidelines waiting for a developer to relay every thought, and they are never left alone in the deep end either. A founder, product manager, designer or client can jump into a session from their browser or phone, explore an idea against the real system, or ask an agent to build a safe experiment on its own branch, while engineers stay focused on architecture and the calls that need their expertise.

Because the conversation, the tasks, the code changes and the verification all live in one place, DevSpec replaces issue trackers like Jira or Linear for teams building with AI agents. You do not need a separate tracker beside it.

Why separate AI chats quietly undo your team's decisions

A coding agent on its own starts every terminal session with amnesia. Even when a developer keeps local instruction files on their laptop, those notes only live in one repo or on one machine. They do not capture what two teammates agreed in a session this morning, why a pricing rule was changed last month, or which choices are settled project policy versus an open experiment.

Worse, standalone AI treats every person who prompts it as the sole decision-maker. If five people on a team run their own AI sessions in isolation, they routinely overwrite each other's work and undo settled architecture without realizing it.

DevSpec solves this at the project level:

• Decisions belong to the project, not to one person's chat history. When a session settles a decision, convention, lesson or risk, DevSpec records it in the project's shared memory with who decided it and why. Every future session and every connected agent reads from that same living record.
• Role-based protection stops accidental reversals. Before an agent starts work or records a change, DevSpec checks it against existing tasks, decisions and conventions. If new work would undo a settled decision, DevSpec flags the conflict and shows whose OK is needed.
• Bold ideas stay safe on their own branch. Protecting decisions never means slowing people down with bureaucracy. Anyone can spin up an experiment or let an agent build waiting work on its own branch to see how it feels in practice. It simply cannot merge into the project's tracking branch until the person whose decision it affects (or the project lead) gives the green light.

See Memories and Review.

A human-in-the-loop that compounds instead of drifting

There is a popular fantasy that the future of software is an autonomous loop where you type a one-paragraph prompt, walk away, and let AI generate the spec, break down the tasks, write the code, and mark its own homework. In practice, every step in an unguided loop compounds the small misunderstandings of the step before it. Five iterations later, the codebase has drifted miles away from what you had in mind, and nobody on the team understands how it works.

DevSpec is built around a compounding human-in-the-loop instead:

1. Rich human context comes first. People bring the real-world goals, user insight and judgment that no model has. Dev and your agents bring instant awareness of your repositories, database schema, production logs and past decisions. Together in a session, you pressure-test the idea until it is sharp.
2. Structured, bounded tasks lock in intent. Once you agree on what to build, Dev turns the conversation into clear tasks with explicit intent (why it matters) and acceptance criteria (what must be true when it ships), grouped under a brief. Your agent works from the full context of the discussion, not a vague one-liner.
3. Every cycle makes the project smarter. What the team and agents learn while building and verifying work feeds back into the project's memories and documents. Instead of drifting further off course with every prompt, each piece of work leaves the next session and the next agent better informed than the last.

Why code and comments are never enough

Teams sometimes ask why they need shared memory if an AI agent can already read the codebase. The answer is simple: code only tells you how the system behaves today, not why it is that way.

When an agent or a new engineer reads an unusual check in your code, they have no way of knowing whether it was a deliberate business decision, a temporary workaround for a third-party bug, or a mistake introduced by another AI session yesterday. Even detailed code comments only describe local mechanics, and agents routinely leave plausible-sounding comments on accidental behavior.

Without a living record of why decisions were made, every new change is a coin flip between preserving a critical rule and enshrining a bug. And when a new developer joins a two-year-old project (or a hundred-person codebase), reading code alone takes weeks. In DevSpec, they can open a session, talk to Dev about why the system is shaped the way it is, and ship meaningful work on day one.

When "done" actually means done

Coding agents love to announce that everything is finished when half the feature is still broken or only tested on the happy path. If your team has to manually pull every branch and click through the entire app to find out what the agent actually did, you have not saved time; you have just turned your engineers and founders into full-time QA babysitters.

In DevSpec, an agent never marks its own work Done:

• Agents stop at Implemented with proof. When your agent finishes a task, it records what it changed and attaches concrete verification evidence for each acceptance criterion: the API test, CLI check, schema check or browser check it ran and what happened.
• It asks when a human eye is needed. If a criterion comes down to visual feel, product taste or a real-world check the agent cannot prove on its own, it says so plainly and asks for human confirmation instead of guessing.
• Unlinked commits do not sneak past. If someone pushes a quick fix straight to GitHub without a task, DevSpec reads the commit, checks whether it touches settled decisions, and creates a tracked item when needed so the record stays honest.

See Tasks and How work flows through DevSpec.

Your own machines, your own stack, and no per-seat tax

Adopting DevSpec does not mean moving your code into a proprietary cloud sandbox or paying a markup on every AI token your agents use.

• Your agents run on your computers. Connect Pi, Claude Code or Antigravity CLI (agy) running on your own machine, using the AI subscriptions or API keys you already pay for. You keep full local speed and access to your local environment, and you can steer those agents from your browser or phone by text or voice whenever you are away from your desk. When an agent is idle, you can also choose to share it with teammates so a non-technical colleague can ask it to build or investigate something without setting up a developer machine of their own.
• Your stack stays yours. Keep your GitHub repositories, your Supabase database, your Axiom logs, and your Vercel or Coolify deployments. DevSpec reads the structure and signals it needs to ground Dev and your agents, and never locks your code into a proprietary runtime.
• One prepaid balance, never per-seat pricing. Per-seat pricing punishes you for bringing the whole team into the room. DevSpec has no seat fees and no monthly subscription tiers: your organization shares one prepaid balance in dollars (starting with $15 on us) that only pays for the work DevSpec itself does, while you control spending with per-person and per-project limits. Invite every engineer, founder, product teammate and client who should be part of the conversation.

See Connect your agent and Billing, usage and limits.

Who DevSpec is for

DevSpec is built for teams who want to move at AI speed on real software without losing grip on their architecture, their product decisions or their budget:

• Executives, founders and product leaders who want to shape the product directly, test ideas in plain English, see honest progress against goals and verified work, and know that one person's late-night prompt will not quietly break the business.
• Developers and technical leads who want their coding agents to arrive already knowing the codebase, schema, logs and past decisions, and who want DevSpec to catch conflicting changes and unverified claims before they land on the tracking branch.
• Product, design and non-technical teammates who want to talk ideas through in the same room as engineers and agents, run safe experiments on a branch, and contribute directly without waiting in a ticket queue.
• Agencies and consultancies who want to bring clients into shared sessions with clear role boundaries (such as Viewer or Reviewed Contributor), capture every decision in writing as it happens, and hand over a living record of what shipped and why.