What Replit Agent's app from scratch workflow tells you about agent specialisation in production

Flashcard·Medium·4.0 · 0·~30s·Asked atCoreweave Vellum Vernacular Ai

Attempt it

Replit Agent runs a strong primary agent with specialist sub-agents that map to distinct phases of app building: an architect step (decide stack and structure), a code-generation step (write the files), an environment-setup step (install dependencies, run migrations), a debugger step (read errors and patch). The specialisations are by phase and by tool surface, not by domain knowledge.

The broader lesson is that production specialisation in 2026 mostly happens along three axes: tool subset (the specialist has access to a narrower toolset), context shape (the specialist gets a different slice of the workspace than the primary), and prompt focus (the specialist's system prompt names a specific job and a specific output format). It almost never happens along the axis of 'specialist model fine-tuned for this role,' because frontier generalist models are still better at every specific role than smaller fine-tuned ones. The architecture earns the win, not the model differentiation.

Your answer

Replit Agent builds entire small apps from a natural language description. The user types 'build me a habit tracker with a Postgres database, a Python backend, and a React frontend,' and the agent produces a working app. Under the hood, Replit Agent runs a primary planning agent and several specialist subagents, each mapped to a distinct phase of the build. - **Architect:** decides the stack and high level structure (which framework, which database, which file layout). - **Code generator:** writes the actual files in the chosen stack. - **Environment setup:** installs dependencies, sets up the database, runs migrations. - **Debugger:** reads error messages from failed runs and patches the code. The specialisations are by phase and by tool surface, not by domain knowledge. The code generator does not know more about React than the debugger does; it just has a different job and a different set of tools. The broader lesson is that production specialisation in 2026 runs on three axes: tool subset (specialist has access to a narrower toolset), context shape (specialist sees a different slice of the workspace), and prompt focus (specialist's prompt names a specific job and a specific output format). It almost never runs on 'specialist model fine tuned for this role,' because frontier generalist models are still better at every specific role than smaller fine tuned ones. The architecture earns the win, not the model differentiation.

Replit Agent illustrates the production pattern for multi agent specialisation in 2026: phase based subagents, each with a constrained tool surface, focused prompt, and tailored slice of workspace context. ### Phase based decomposition Phases are sequential and visible in the build log: architect decides the stack, code generator writes files, environment setup installs and configures, debugger reads errors and patches. Each phase has its own success criterion and failure mode, which is why each gets its own agent rather than being lumped into one mega prompt. ### The three axes of real specialisation All subagents use the same frontier model (Claude Sonnet 4.6 or GPT 5.5 in 2026 production). They differ on three axes: - **Tool subset.** The code generator has file edit tools; environment setup has shell and package tools; the debugger has log read and patch tools. Each agent's tool list stays small, keeping selection accuracy high. - **Context shape.** The architect sees the user request and a stack catalogue; the code generator sees the plan plus relevant files; the debugger sees the failing error plus the file that caused it. Narrow context per agent. - **Prompt focus.** Each subagent's prompt names one job and one output format. Focus on what to produce, not on general skills. ### What does not happen: per role fine tuning In 2026, fine tuning a small model per role mostly does not pay off. Frontier generalists are still better at every role than smaller specialists. The win is in the architecture, not the model choice.

TL;DR

Production specialisation in 2026 runs on tool surface, context shape, and prompt focus, almost never on fine tuned per role models; frontier generalists still beat smaller specialists.

Memory aid

Easy to grasp

Picture a small construction crew building a house. The same skilled person could in theory do everything, but on a real job site you have a planner who decides the layout, a framer who puts up walls, an electrician who runs wires, and a painter who paints. The framer is not a better human than the painter; they have different tools, different focus, and a different part of the blueprint in their head. They are all just very capable people in specific roles. Replit Agent works the same way. The same frontier model plays each role, but each role has its own tools, its own slice of the project, and its own job description. The differentiation is architectural, not biological.

Key concepts

Multi agent systems Agents

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Replit Agent is a useful case study because the public product surface makes the multi agent architecture visible: the build log shows distinct phases (architect, code generation, environment setup, debugger), each visibly handled by a different subagent. The architecture is a worked example of how production specialisation actually works in 2026.

This answer walks through the phase decomposition, names the three axes on which real specialisation runs, contrasts with the intuitive but wrong assumption that fine tuning per role is required, and ends with a practical rule for designing specialised subagents.

The phase based decomposition of Replit Agent

Building an app from a natural language spec is a sequential process with clearly distinct phases. Replit Agent reflects those phases as visible subagents in the build log.

Architect

Reads the user request, decides on the stack (framework, database, deployment target), and produces a structural plan: file layout, key dependencies, integration points. This is the highest level reasoning step; the output is a plan, not code.

Code generator

Reads the architect's plan and produces the actual code files. Has file write and edit tools, knows the chosen stack, and is prompted to produce minimal runnable code that matches the plan.

Environment setup

Installs dependencies, configures the database, runs migrations, sets environment variables. Has shell and package manager tools but does not write application code.

Debugger

Reads error output from failed runs and patches the code. Has log read and file edit tools and a prompt focused on minimal diagnostic patches rather than wholesale rewrites.

Why this decomposition

Each phase has a distinct success criterion (architect: a coherent plan; code generator: runnable files; environment setup: a working environment; debugger: a passing run). Each has a distinct failure mode (architect: incoherent stack choice; code generator: missing imports; environment setup: missing dependencies; debugger: making things worse). Splitting them lets each subagent be evaluated, prompted, and tooled for its specific job.

Axis 1: tool subset

Axis 2: context shape, Axis 3: prompt focus

The fourth axis that mostly does not win, and why

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Axis of specialisation	What changes	When it earns its keep
Tool subset	Narrower tool list per agent	Keeps each agent under the 15 to 20 tool reliability threshold
Context shape	Narrower slice of workspace per agent	Reduces per turn cost and attacks lost in the middle
Prompt focus	Specific job and output format per agent	Sharper output than generalist prompts produce
Fine tuned per role model	Different model weights per agent	Rarely worth it in 2026; frontier generalists still win

Real products, models, and research that use this idea.

Replit Agent's 2025 and 2026 product surfaces an architect, code generator, environment setup, and debugger as visible phases in the build log, matching the architecture this question describes.
Cursor agent mode follows the same pattern with planner, search, editor, and shell subagents, all using the same frontier model with different tools and contexts.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you decide which phases of a workflow deserve their own subagent versus being absorbed into a neighbour?

A phase deserves its own subagent if it has a distinct tool surface, a distinct context slice, or a distinct prompt focus that the neighbour does not share. If a phase has none of these, it is a step in the neighbour's job, not a separate role.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Assuming production specialisation requires fine tuning a small model per role, and missing that the actual axes are tool subset, context shape, and prompt focus, all with the same frontier model under the hood.

60 second bullets to scan on the way to the call.

The phase based decomposition of Replit Agent and why it matches app building
The three axes of production specialisation (tool subset, context shape, prompt focus)

Primary sources. Browse if you want the original framing.