The developers making $40,000/month with Claude Sonnet 5 all use the same system. Here it is.

Most developers who try Claude Sonnet 5 use it the same way they used ChatGPT - open a chat, paste some code, ask a question, copy the answer. They get a useful response and move on. They think they're using AI for development.

They're not. They're using a frontier model as a search engine.

Bookmark This and follow

- I'm Sprytix, a developer who builds AI systems and automation pipelines that turn technology into real income. DMs open.

The developers making real money with Claude Sonnet 5 built something completely different. Not a prompt. A system. One where Claude reads the entire codebase before writing a single line, plans before it codes, runs tests after every change and opens pull requests automatically. One where the developer's job shifted from writing code to reviewing it.

Claude Sonnet 5 has 886,000 commits across 17,000+ open source projects. Stripe used Claude Fable 5 to migrate a 50 million line Ruby codebase in one day - work that would have taken a team two months. It worked autonomously for 9.5 hours building a complex research analysis tool without a single human intervention.

The difference between those results and a developer who gets mediocre output from the same model is not the model. It's the system around it.

Here's the exact system.

Why Fable 5 changes the ceiling

https://x.com/claudeai/status/2072402636813607381

Claude Sonnet 5 handles the daily workflow. Fable 5 is what happens when the task is too complex for anything else.

Anthropic positioned Fable 5 not as a chat upgrade but as an agent - something that doesn't answer questions but finishes projects. The difference shows up immediately in what it can actually do autonomously.

Stripe handed it a 50 million line Ruby codebase and a migration task. One day later the migration was done. A team of senior developers estimated two months for the same work. Fable 5 didn't write faster - it planned better, understood dependencies across millions of lines simultaneously and executed without losing context halfway through.

In a separate benchmark it worked autonomously for 9.5 hours building a complex research analysis tool. No check-ins. No corrections. No human in the loop until the work was complete.

1Sonnet 5     |  daily development, client work, automation
2Fable 5      |  complex migrations, long autonomous tasks, frontier reasoning
3Claude Code  |  routes between them automatically based on task complexity

The practical implication for a solo developer running this system: Sonnet 5 handles 80% of the work at a fraction of the cost. Fable 5 handles the 20% that would otherwise require a senior architect - the tasks where getting it wrong means days of cleanup.

Claude Code Router reads the complexity of each task and assigns it automatically. Simple feature implementation goes to Sonnet 5. Large-scale refactoring, security audits and architectural decisions go to Fable 5. The developer pays for the right model on the right task and never underpowers a complex job.

Why most people get average results

Claude Sonnet 5 without a system works like this:

1Question    |  developer types prompt
2Response    |  Claude answers in isolation
3Result      |  one function, one file, no context

Claude Sonnet 5 with a system works like this:

1Repository  |  Claude reads everything first
2AGENTS.md   |  Claude knows the architecture
3Plan        |  Claude writes implementation plan
4Approval    |  developer reviews and confirms
5Code        |  Claude implements one feature at a time
6Tests       |  Claude runs tests after every change
7PR          |  Claude opens pull request automatically

The output from the second workflow is not 10% better. It's categorically different - the kind of work that used to require a senior developer and two weeks now takes Claude and one afternoon.

https://x.com/claudeai/status/2072017450611142835

The four files that change everything

The most important insight from 17,000+ repositories using Claude Code is this: the developers getting the best results don't write better prompts. They build better context.

In 2024 the advantage was prompt engineering. In 2026 the advantage is repository engineering - building the files and structure that make Claude understand your entire project before it writes a single line.

Four files do most of the work.

AGENTS.md

Every serious Claude Code repository has this file. It tells Claude everything about the project that it would otherwise have to figure out from scratch every session.

1Never use axios. Always use fetch.
2Every component: TypeScript, Tailwind, Server Actions.
3Testing: Vitest for unit, Playwright for E2E.
4Never commit directly to main.
5Always open a PR.
6Run npm test before every commit.

Claude reads AGENTS.md at the start of every session. After that it never needs to be told these rules again. The file is the permanent memory of how this project works.

CLAUDE.md

The broader project context. Architecture decisions, folder structure, why certain choices were made, what to avoid. Claude reads this and understands the project like a developer who has worked on it for months.

skills/

The system that separates power users from everyone else. Instead of rewriting the same instructions every session, skills are reusable workflow files Claude can call on demand.

1skills/
2  frontend.md    - Tailwind, Next.js, SEO, accessibility rules
3  backend.md     - API patterns, error handling, logging standards
4  security.md    - auth patterns, input validation, OWASP rules
5  deployment.md  - Docker, CI/CD, environment variables
6  database.md    - schema conventions, migration patterns, query rules

Call them with one line:

1@frontend - build the landing page for the pricing section
2@security - audit the authentication middleware
3@database - create a migration for the new user roles table

Claude already knows everything in that skill file. No re-explaining. No context lost between sessions.

The planning prompt

The single most important prompt in any serious Claude Code workflow:

1Read the entire repository.
2Understand the architecture completely.
3Do not write any code yet.
4Write a detailed implementation plan for this feature.
5List every file you will touch and why.
6List every edge case you anticipate.
7Wait for my approval before implementing anything.
8After approval: implement one feature at a time.
9Run tests after every change.
10Show me the diff before committing.

Every top repository follows this pattern. Research first. Plan second. Implement third. Never the other way around.

The subagent system

The most powerful setup is not one Claude doing everything. It's specialized agents each doing one job - the same way a development team works, except each specialist is Claude with a different context file.

1Research Agent   |  finds best libraries, reads docs, evaluates options
2Planning Agent   |  breaks down features into implementation steps
3Coding Agent     |  writes the actual code
4Review Agent     |  checks for bugs, security issues, code quality
5Deploy Agent     |  handles CI/CD, environment config, releases

The workflow for a new feature:

1/research   - find the best authentication library for our stack
2/planner    - create implementation plan for OAuth login
3/coder      - implement the plan
4/reviewer   - review the entire PR for security issues

One model. Four specialists. A complete feature from research to reviewed pull request without a single context switch from the developer.

This is what Stripe used at scale. Not one Claude session doing everything - a coordinated system where each stage has the right context to do its specific job well.

The tools that complete the system

Three open source repositories plug directly into this workflow.

OpenCode - github.com/sst/opencode

The terminal interface that makes Claude Code actually workable at scale. OpenCode reads the entire repository, makes edits across multiple files simultaneously, runs the code, fixes errors automatically and shows a clean diff of every change before committing. The developer sees exactly what changed and approves or adjusts before anything hits the repository.

Claude Code Router

Not every task needs the most capable model. Claude Code Router reads the complexity of each request and routes it accordingly:

1Simple task      |  faster cheaper model
2Complex refactor |  Claude Sonnet 5
3Security audit   |  Claude Fable 5
4Docstring fix    |  fast model, done in seconds

At scale this cuts API costs by 40-60% without reducing output quality on the tasks that matter.

Serena

The problem with large codebases is that Claude can't read 5,000 files efficiently. Serena solves this by finding only the files relevant to the current task - if you're working on authentication, Serena surfaces the auth middleware, the session handler and the login controller. Claude works with exactly what it needs. Fewer tokens. Faster output. Better results.

The businesses built on this system

The system above is not just a better way to code. It's the infrastructure for software businesses that one person can run.

Web Development Agency - a solo developer using Claude Sonnet 5 with the full system delivers websites and web applications in one to two days that used to take a junior developer one to two weeks. The quality is indistinguishable because Claude runs the same tests, follows the same conventions and opens the same pull requests a human developer would.

1Client brief      |  requirements document
2Research Agent    |  stack selection and architecture
3Planning Agent    |  feature breakdown and timeline
4Coding Agent      |  implementation with full test coverage
5Review Agent      |  security audit and code quality check
6Delivery          |  reviewed, tested, documented codebase

4 projects at $2,500 each - $10,000/month. Delivery time per project: two days.

Automation Agency - companies need internal tools constantly: dashboards, CRMs, admin panels, reporting systems. These are not complex products but they take developer time that most companies don't have. Claude Sonnet 5 with the right system builds them faster than any in-house team.

6 clients at $2,000/month retainer - $12,000/month.

Research and Documentation - technical documentation, API docs, codebase audits, architecture reviews. Claude reads everything, Claude Code Router handles the complexity routing and the output is senior-developer-quality analysis at a fraction of the time.

5 projects at $1,500 each - $7,500/month.

SaaS Product - the most valuable use of the system. Building a real product solo that would have required a team of three to five developers two years ago. Claude handles 80% of the implementation. The founder handles product decisions and client relationships.

One product at $15,000/month in recurring revenue after six months of building.

1Web Agency       |  4 projects   |  $10,000/month
2Automation       |  6 clients    |  $12,000/month
3Research         |  5 projects   |  $7,500/month
4SaaS Product     |  1 product    |  $15,000/month
5------------------------------------------------
6Total            |               |  $44,500/month
7Tools cost       |               |  $50-150/month
8Margin           |               |  99%

The setup that takes one weekend

Day 1 - Build the foundation. Create AGENTS.md with your coding standards, technology choices and workflow rules. Create CLAUDE.md with architecture overview and project context. Build three to five skill files for your most common tasks.

Day 2 - Build the agent system. Set up the research, planning, coding and review agents with their specific context files. Test the full workflow on a real feature from research to pull request. Install OpenCode and connect it to your workflow.

Day 3 - Find the first client. Every agency, startup and growing company needs web development work. Show them a feature built with the system from brief to reviewed PR. The speed and quality close the deal.

The first project is the proof of concept. After that the system replicates - same agents, different AGENTS.md for each client's codebase, same quality every time.

The shift that changes everything

In 2024 the best developers wrote the best prompts. In 2026 the best developers build the best systems.

A great prompt gets Claude to write one good function. A great system gets Claude to manage an entire software project - reading the codebase, planning the implementation, writing the code, running the tests and opening the pull request - while the developer focuses on the decisions that actually require human judgment.

Claude Sonnet 5 handles the daily work. Claude Fable 5 handles the complex problems that used to require a team. Claude Code Router assigns the right model to the right task automatically. The developer sits above the system and makes the calls that actually matter.

That is not a better way to code. It is a different job entirely.

Most developers will keep using Claude like a chatbot and wonder why their results are average. A few will spend one weekend building the system above and never go back.

/ If this was useful - follow, the next one drops here first.