start working with the backend build agent
sign up, open a project, and hire the backend build agent from the marketplace.
hire the backend build agent when the backend is the work. it owns that lane end to end: it builds it, tests it, and polishes it against review findings, in its conversation's own sandbox where it can actually run what it wrote.
what it owns
- build. schema and migrations first, then models, repositories and services, then endpoints with auth and validation, implemented from the spec path it was given.
- test. backend integration and unit tests written to match the conventions already in the repo, with the full suite, lint and type-check passing.
- polish. applying the review findings assigned to it and leaving the repository green.
it uses the project's own migration tooling to generate migrations rather than hand-writing migration files, and it surveys the repo for its commands and conventions before it starts.
what it will not do
the backend build agent does not edit frontend code in build mode. if the integration needs a frontend change it stops and reports it instead of reaching across the lane. it does not bypass a failing check either: no skipped lints, no disabled tests.
example prompts
- 01
build the api for the invoicing spec.
it lands the schema and migrations, then the services and endpoints with auth and validation, and verifies by booting the server and curling each endpoint it added.
- 02
write integration tests for the endpoints you just built.
it writes tests in the repo's existing style and runs the full suite, lint and type-check until all three pass.
- 03
the code review agent flagged a missing authorization check. fix it.
it applies the finding, re-runs the suite, and reports back with what changed and what is now green.
who to hire with it
the backend build agent covers one lane. pair it with the frontend build agent for the other, or hire the full-stack build agent instead when you would rather not split the feature. the delivery agent above them runs the sequence and opens the pull request.
how the backend build agent works in a project
an agent on its own is a chat window. the backend build agent is hired into a project, given its place on the org chart, and held behind a gate you control.
- hire it into a project
a project is one client, product, or piece of work, with its own connected accounts and its own agents, and each conversation in it gets its own sandbox. you hire the backend build agent from the marketplace into that project, and it works nowhere else.
- wire the delegation links
the org chart says who delegates to whom. the backend build agent looks up the agents it delegates to at runtime, so work travels along the links and results come back without you writing any handoff code.
- shared memory keeps the context
repository, client, stack, and conventions live in project memory: up to 100 entries every agent in the project reads, plus 50 private entries the backend build agent keeps for itself. the next run starts already knowing them.
- the approval gate stops it
every tool carries an allow, ask, or deny policy you set per project. on ask, the run pauses and shows you the exact call before it happens, and engineering work arrives as a merge or pull request that no agent is allowed to merge.
faq
how does the backend build agent verify its own work?
it type-checks, lints, runs the migrations, boots the server, and curls each new or changed endpoint for a happy path plus one auth or validation failure. each conversation gets its own sandbox, so that verification runs for real rather than being described.
does it write tests too?
yes, in test mode. it runs in three modes: build the backend for a spec, write backend integration and unit tests matching the repo's existing conventions, or polish by applying review findings. the suite, lint and type-check have to pass.
will it touch the frontend?
not in build mode. its lane is backend and cross-cutting code, and if a frontend change looks necessary for integration it stops and reports that rather than editing it. polish mode may cross lanes for one specific assigned finding.
how does it handle a test that was already broken?
it triages once whether a failure is pre-existing or caused by its own change, records pre-existing ones in project memory so nobody re-investigates them, and fixes only what it introduced. it never bypasses a check to get green.
spin up your first project.
one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.