Meet the team that works while you sleep
A real delivery org, not a megaprompt: one human who makes every decision, and specialized agents with tight charters, clean handoffs, and an auditable artifact at every stage. Every profile below links to that agent's actual charter in the repo.
11 agents on staff · 1 opt-in specialist · hallucinating across roles: not permitted
Each role has its own prompt, tools, and owned paths. A narrow charter means fewer hallucinations — no agent speaks for another's domain.
Every handoff leaves a document you can read — PRD, stories, spec, plan, review learnings. The paper trail is the org chart.
Domain agents run sequentially on a shared branch, never in parallel. Order is enforced: schema first, review last.
Agents keep per-role memory archives, and QA writes review learnings back after every story. The team gets better at your repo over time.
Approves every gate. Reviews every PR. The only member who sleeps — the org is built around that.
reads: everything · reports to: no oneProduct
Turns vague ideas into unambiguous, buildable work — in product language only. No entity names, no API paths.
Converts a vague feature idea into a full PRD — problem statement, personas, user stories, binary acceptance criteria, success metrics, out-of-scope boundaries.
If your idea is under two sentences, expect exactly one clarifying question.
Two modes: decomposes an approved Epic into dependency-ordered Jira stories, or triages a rough stakeholder ticket into a well-formed story in place.
Fixes your tickets without complaining about them in standup.
Architecture & Planning
Where WHAT gets decided before any HOW. Specs with no TBDs, plans with no task spanning two agents.
Converts an approved story into a complete technical spec — data model, API surface, permission matrix, sync rules. Jira is the only product context it will accept.
A finished spec may not contain the letters T, B, D in that order.
Breaks the spec into concrete, ordered, agent-tagged tasks — schema first, review last — each phase ending in a verification step with real gate commands.
No task may span two agents. If it touches two domains, it gets split.
Engineering
One orchestrator, five domain specialists. Sequential by design — never two agents on the branch at once, and each touches only the paths it owns.
Executes the plan: dispatches domain agents in strict dependency order on the shared story branch, pushes their commits, and opens the PR once QA returns clean.
Never two agents at once. Chaos is a process failure, not a vibe.
Owns the relational schema — entities and migrations. Always runs first when new tables are needed; everything downstream builds on its work.
Schema before anything. Non-negotiable.
Server-side infrastructure and serverless application code — handlers, stacks, config. Tech stack is whatever your repo says it is.
Will not touch your lockfile. Ever.
The offline-sync layer — sync rules, transaction builders, schema typegen, dead-letter queue. Runs only when the story needs offline writes.
The specialist you forget exists until your app works on a plane.
The web frontend — pages, components, data hooks, client state. Scope is the web app workspace and nothing else.
Strict TypeScript. The word "any" is a code smell, not a type.
Mobile screens, components, navigation, and offline-read hooks — the mobile app workspace end to end.
Tests on-device assumptions the web team never has to think about.
Quality
Independent by construction: review is done by a different agent than the author, and nothing merges on vibes.
Runs the review → fix → learn loop until the branch is clean: independent code review, quality gate with pasted output, acceptance-criteria verification, and learnings written back to team memory.
Never writes feature code. Finds the owner and makes them fix it.
On contract
Joins only when a repo opts in at /sdlc:init — with a hard write-scope and a human-confirmation gate on every fix.
Owns the repo's AI-configuration surface — CLAUDE.md, .claude/**, plugins/**, skills/** — scanning for drift, gaps, and config-vs-memory conflicts, and applying fixes only as reviewable diffs after human confirmation.
The only agent allowed to edit the handbook — and only with your sign-off.
Every employee follows the same first day, every day
- 1. read project-context.md — the one file that makes generic agents yours
- 2. load required skills — TDD, executing-plans, verification-before-completion
- 3. read your project override — .claude/project/agents/<you>.md — and invoke every skill it lists
- 4. read your memory archive — .claude/memories/agents/<you>.md
- 5. touch only the paths you own — the workspace table is the law
- 6. commit conventionally, leave your artifact, hand off clean
Hire the whole team in 60 seconds
No interviews, no onboarding docs, no salaries. One config file per repo and they start tonight.