How a one-person dev studio runs with autonomous AI agents

TL;DR (for the impatient)

• BaoDev.studio is a one-person dev studio paired with a fleet of autonomous AI agents.
• The workflow is built around Claude Code and ~35 specialized agents that operate like a fractional engineering team.
• Pricing: $800 for a sprint (1–5 days), $4,500 for a system build (2–8 weeks), $3,000/month retainer (3-month minimum).
• Delivery times are honest. Token costs are real. AI agents do not replace senior judgment — they multiply it.
• This post: the stack, the actual numbers, the trade-offs, and what AI still cannot do.

The gap nobody talks about

A founder needs an MVP, a payments integration, or a Go service that does not fall over. Two options usually surface:

Option 1: Freelancers on Upwork / Sribu / Kalibrr. Cheap. Sometimes great. Often a coin flip. Someone billing 8 clients in parallel, copy-pasting from Stack Overflow, disappearing for 3 days when something breaks. $15-30/hour and a "1 week project" becomes 6 weeks.

Option 2: An agency. Senior people, real processes, predictable output. Also $20,000 minimum, 8-week kickoff, and a project manager emailing status updates while the actual work waits in a sprint queue.

The gap in the middle — "senior engineering quality, this month, for less than the price of a used car" — is where most actual SME projects live. Nobody was serving it well, because the unit economics of doing senior work at freelance prices have not existed.

Until AI agents got good enough.

What BaoDev actually does all day

This is not "vibe coding". Not pasting prompts into ChatGPT and pretending. The studio runs an instrumented engineering pipeline that looks something like this:

1. Intake. Client fills the form on baodev.studio describing what they want. The studio reviews. If a project is outside what can be delivered well, the answer is no — saying no honestly is worth more than saying yes to fail later.

2. Plan and contract. A planning agent drafts the PLAN.md (14 sections: scope, architecture, risks, milestones, dependencies). A senior engineer reviews and edits. A contract is signed before any code is written.

3. Build. Most people imagine the AI just writes everything. It does not. The actual flow:

• A flow-architect agent maps every page → API → DB → job → notification connection and flags gaps.
• A backend-developer or frontend-developer writes the first pass.
• A quality-gate reviews every output before it hits the codebase.
• An integration-test-agent writes tests that hit a real database, not mocks.
• A security-engineer runs OWASP checks before deploy.

When something is non-obvious — a tricky algorithm, an architectural fork, a client decision — a human takes over. Agents are good at executing the boring 80%. Senior judgment owns the 20% where it matters.

4. Ship. The CI pipeline includes the agents as checks. Every PR runs 0qa, scoring on completeness, security, performance, and tests. Score has to be ≥90 with zero critical findings or the PR does not merge.

This stack is ~35 agents, all custom-built and version-controlled in the same repo. The roster lives in ~/.claude/agents/. They run on Claude Code locally — no cloud bill, no quota anxiety.

Real numbers from real projects

Vague case studies are useless. Concrete data points instead:

Project: SaaS dashboard MVP (Next.js + Go API + Postgres + Stripe)

• Quoted: $4,500, 4 weeks
• Delivered: $4,500, 3 weeks 2 days
• Token cost end-to-end: ~$140 of Claude usage
• Lines shipped: ~14,000 (without counting tests)
• Tests: ~4,200 lines, 91% statement coverage
• Bugs found in client UAT: 3 (1 critical fixed in 4 hours; 2 cosmetic)

Project: Bug fix sprint (Go service, race condition in worker pool)

• Quoted: $800, 2 days
• Delivered: $800, 6 hours
• Token cost: ~$8
• Outcome: race fixed, regression test added, root cause documented in the runbook

Project: AI integration (LLM-powered support agent for a small e-commerce site)

• Quoted: $4,500, 6 weeks (deferred to phase 2 by client after week 3 — normal scope-creep)
• Delivered phase 1: $4,500, 3 weeks
• Token cost (dev only, not runtime): ~$200
• Phase 2 ongoing as retainer

The unit economics work because token cost is a rounding error against engineering time. The constraint is not "how cheaply can the AI write code" — it is "how reliably can a senior direct it without re-doing everything by hand". That part had to be invented.

What AI agents cannot do

Honest list. These do not get better with bigger models.

1. Tell a client they are wrong. A founder asks for a feature that will tank their conversion rate. Agents will build it. A senior pushes back.
2. Pick the right database. Postgres or Mongo, Redis or Memcached, monolith or microservices — these are architectural decisions tied to business stage and team future. Agents pick whatever you suggest. They will not catch the suggestion that is wrong for your stage.
3. Read code politically. Some refactors are technically clean and politically dead. Agents do not know your CTO has a feud with the previous lead.
4. Catch the subtle copy-paste bug. Agents will sometimes write a 200-line file that compiles, runs, passes tests, and is silently wrong because they copy-pasted a constant from a similar service.
5. Decide what NOT to build. Scope discipline is a senior trait. Agents are happy to scaffold a feature you do not need.

This is why the model is not "buy an AI subscription instead of a developer". It is "buy a senior developer who has an AI workforce". The agents do not replace humans — they let one senior ship the work of 4-6 mid-level engineers without the overhead of 4-6 people.

The pricing model

Three engagement types, all flat:

• Sprint — $800 per deliverable, 1–5 business days. Use this for one isolated thing: a feature, a bug, an integration, a migration. No ongoing commitment.
• System build — $4,500+, 2–8 weeks. Full system delivered: backend, frontend, database, deployment, tests, docs. Fixed scope, fixed price, fixed timeline. SLA signed, system delivered.
• Ongoing retainer — $3,000/month, 3-month minimum. Reserved engineering capacity for continuous work — new features, on-call, code review, iterative product.

No hourly billing. No "+30% if the project runs over". Estimates are honest, with a buffer. If a project hits its deadline early, the client gets the work earlier. If something was missed in scoping, the studio absorbs it — not a change order.

Bilingual EN/ID. Asynchronous communication by default. Email-first. Async beats meetings 9 times out of 10.

Why this post exists

Two reasons:

1. To find clients who fit. If your project lives in the SME band — between Upwork-cheap and agency-expensive — the intake form on baodev.studio is the right starting point. Services page has full pricing. Open-source showcase projects are linked from the projects page.
2. To document a workflow that was not possible 18 months ago. The economics of senior engineering + AI agents are real, and they are reshaping who can sustainably run a small studio. Worth contributing to that conversation.

If this resonates, the intake form on baodev.studio is the right next step. Every legitimate inquiry gets a response within 24 hours, in English or Bahasa. If the project is a fit, a contract is signed within a week. If not, a referral comes instead.

BaoDev.studio. Senior engineering paired with autonomous AI agents. Production-grade systems. No agency overhead.

---

Originally published at baodev.studio