How software gets built — and how AI changes it
The map of the field: how classic teams and pipelines work, how Claude reshapes them, and which agent framework to actually reach for.
Why start here: before you build (Weekend 1) or wrap a model in a harness (Weekend 2), it helps to see the world these tools live in. Once you can see it, choosing a tool stops being guesswork and becomes a real decision.
How the "legacy" software world works
Two ways to run a project, who does what, and how code reaches users.
A.1 Waterfall vs Agile
For the non-tech learner
Waterfall is the older, linear way: fixed phases in order — requirements → design → build → test → release — each finished before the next, with heavy up-front documents. Predictable, but slow to change. Agile is the iterative way that replaced it for product work: build in short cycles (sprints, 1–2 weeks), ship a small slice, then adapt. Scrum = fixed sprints with roles and ceremonies; Kanban = a continuous flow board.
flowchart LR
R[Requirements] --> D[Design] --> B[Build] --> T[Test] --> Rel[Release]
Waterfall — one pass, front to back.
flowchart LR
P[Plan] --> Bu[Build] --> Te[Test] --> Rv[Review] --> P
Agile — repeat every sprint.
| Waterfall | Agile | |
|---|---|---|
| Shape | One pass | Repeating loops |
| Change | Expensive, discouraged | Expected, welcomed |
| Best for | Fixed scope, regulated | Evolving products |
| Risk | Find problems late | Find problems early |
The link to your course
Waterfall is a straight line; Agile is a loop — the same contrast you'll meet as "pipeline vs agent loop." The industry learned about teams what you'll learn about agents: loops adapt better.
A.2 The standard team
For the non-tech learner
A delivery team splits work across specialists. In small shops one person wears several hats; in big ones each is a department.
| Role | Owns |
|---|---|
| PM — Product/Project Manager | the "what" & "why", priorities, roadmap, schedule, scope |
| BA — Business Analyst | requirements, user stories, acceptance criteria |
| SA — Solution/System Architect | the technical blueprint, tech choices, data flow, trade-offs |
| UI/UX Designer | what users see & how it feels — research, wireframes, mockups |
| Dev — Developers | build it: write the code (frontend, backend, …) |
| QA — Quality Assurance | make sure it works: tests, bug-finding, release sign-off |
Scrum teams often add a Scrum Master (runs the process) and a Product Owner (owns the backlog).
A.3 From source code to production
For the non-tech learner
DevOps joins "Development" and "Operations" so software moves safely from a laptop to live users, mostly automated. It passes through environments — separate copies of the app: local/dev (your machine), CI (auto build+test on every change), test/QA, staging (a production mirror for final sign-off / UAT), and production (live users). CI/CD = auto build/test/deploy on change.
flowchart LR
DEV[Developer + AI<br/>writes code] --> PR[Pull request<br/>code review]
PR --> CI[CI: build + tests<br/>automated gate]
CI --> QA[Test / QA]
QA --> STG[Staging<br/>pre-prod mirror + UAT]
STG --> PROD[(Production<br/>live users)]
PROD -.monitoring and feedback.-> DEV
Everything you build in Weekend 2 (a test gate, staging, a deploy pipeline, monitoring) is a small version of this. You already speak this language.
How Claude transforms the legacy way
AI doesn't delete the roles or stages — it compresses them and shifts where humans spend their time.
B.1 The same job, reshaped
For the non-tech learner
The pattern is the same everywhere: the model drafts and executes; the human sets direction, judges, and reviews. Anthropic's "AI Fluency" lens — Delegation, Description, Discernment, Diligence — decide what to hand off, describe it well, judge the output, verify it.
| Stage / role | Traditionally | With Claude in the loop |
|---|---|---|
| BA requirements | interviews, docs by hand | Claude drafts PRDs, user stories, acceptance criteria; you refine |
| SA architecture | architect designs it | Claude proposes designs & trade-offs; a human still decides |
| UI/UX | wireframes, mockups | Claude Design & agents generate mockups and components |
| Dev build | engineers write it all | Claude Code writes/edits code agentically (with review & tests) |
| QA testing | testers write suites | Claude writes tests & evals; an eval gate blocks bad output |
| DevOps ship | ops writes pipelines | Claude scaffolds Dockerfiles, CI/CD, deploy scripts |
| PM coordinate | planning, status | Claude drafts plans, updates, tracks work |
What actually changes
The judgment work concentrates and the production work spreads out — one person plus agents can cover what used to need a small team. That's exactly why harness engineering matters: the scaffolding around the model keeps the result trustworthy.
B.2 The team, re-created as agents
For the non-tech learner
A striking move you'll see next: several frameworks literally re-create the team of roles as agent personas — an Analyst agent, an Architect agent, a QA agent — with an orchestrator coordinating handoffs. The human stays on top for direction and review.
flowchart LR
H[Human: direction,<br/>judgment, review] --> ORCH{Orchestrator}
ORCH --> A1[Analyst / BA agent]
ORCH --> A2[Architect agent]
ORCH --> A3[Developer agent]
ORCH --> A4[QA / test agent]
A1 --> ART[(Shared artifacts:<br/>PRD, plan, code, tests)]
A2 --> ART
A3 --> ART
A4 --> ART
ART -.review.-> H
Harness frameworks: what to use
These sit at different layers and often compose rather than compete. Strengths, weaknesses, and a picker.
Two layers to keep straight
For the non-tech learner
Base agents (the harness itself): Claude Code, Cline, the Roo-family IDE agents. Methodology layers on top: Superpowers (a Claude Code plugin) and BMAD (a process framework) add discipline and role structure on top of a base agent.
⚠ This field changes monthly
Versions, star counts, and even whether a tool still exists change fast — one popular option below was discontinued in May 2026. The figures here are mid-2026 snapshots; always check a project's current status before committing.
C.1 Claude Code — the foundation
Anthropic's own agentic coding tool (terminal, desktop, IDE). It is a harness: it runs the plan→act→observe loop, uses tools, reads a CLAUDE.md, and supports subagents, plugins, skills, and MCP.
| Strengths | first-party & well-maintained; Plan Mode; plugin/skills ecosystem; the model you already know |
| Watch-outs | supplies the engine, not the methodology — can wander on big tasks without added structure |
| Best for | everything, as the base — pair with a methodology layer for real projects |
C.2 Superpowers — discipline on top of Claude Code
An open-source (MIT) skills framework + methodology by Jesse Vincent ("obra"), one-command install from Anthropic's official plugin marketplace. It injects senior-engineer discipline: a brainstorm → write-plan → execute-plan flow, strict test-driven development (tests must fail before code; code written before its test is deleted), systematic debugging, and subagent-driven development with built-in code review. Token-light, hugely adopted.
/plugin install superpowers@claude-plugins-official
| Strengths | enforces the habits beginners skip (spec first, tests first, review); low context overhead |
| Watch-outs | opinionated — the mandatory TDD/ceremony is overkill for a throwaway script; it's a methodology, not a separate agent |
| Best for | bringing production discipline to Claude Code on any real project |
C.3 BMAD-METHOD — a full AI "agile team"
Open-source (MIT) framework — Breakthrough Method of Agile AI-Driven Development — that structures the whole lifecycle as agent personas (Analyst, PM, Architect, PO, Scrum Master, Developer, QA, Orchestrator) across four phases: Analysis → Planning → Solutioning → Implementation. Scale-adaptive, installs via npx, works with Claude Code / Cursor / Codex; very widely adopted (~49k stars, v6.x, mid-2026).
npx bmad-method install
| Strengths | simulates a real product team; auditable handoffs & quality gates; scales to large/regulated work; model-agnostic |
| Watch-outs | heavy for small projects — real ceremony (personas, docs, handoffs); a learning curve |
| Best for | larger, multi-part, or governance-sensitive builds. Overkill for weekend-sized tasks. |
C.4 Cline — careful, human-in-the-loop IDE agent
Open-source (Apache 2.0) agent for VS Code and JetBrains, and the upstream the Roo family forked from. Its signature is a Plan/Act two-phase workflow: the agent plans, then executes with your approval at each step, leaving a full audit trail. Category leader by adoption (5M+ installs, ~58k stars, mid-2026), well-funded, BYO-key.
| Strengths | tight control & audit log; IDE-native; JetBrains support; safe for critical codebases; mature |
| Watch-outs | all those approvals slow big autonomous jobs; single-agent (no built-in multi-mode orchestration) |
| Best for | careful, methodical, or regulated work — and beginners who want to approve each change |
C.5 Roo Code — discontinued; use its successors
Roo Code was a popular VS Code agent (a Cline fork) known for exactly the orchestration you'd want: a multi-mode system (Code / Architect / Ask / Debug) and "Boomerang Tasks" — an orchestrator spawns specialized sub-agents, and you can route each mode to a different (cheaper or stronger) model to cut cost.
Status — important
The Roo Code extension was shut down on May 15, 2026 and its repo archived; the team pivoted to a Slack-first product. Don't start a new project on Roo Code. Use instead: Zoo Code (a community fork with an official handoff — near drop-in, imports your Roo settings), Kilo Code (another Roo-family fork), or Cline (the upstream, which the Roo team itself recommended).
| Strengths (the style) | multi-agent orchestration (Boomerang) + per-mode model cost-routing + custom modes |
| Watch-outs | discontinued — reference only |
| Best for | that orchestration style — now via Zoo Code or Kilo Code |
Side by side
| Framework | Layer | Superpower | Main weakness |
|---|---|---|---|
| Claude Code | Base agent | first-party, plan mode, plugins | needs a methodology on top |
| Superpowers | Methodology | enforced spec-first + TDD + review | ceremony overkill for tiny tasks |
| BMAD-METHOD | Process framework | full "AI team" + governance | heavy/complex for small projects |
| Cline | Base agent (IDE) | Plan/Act, approve-each-step | slower for big autonomous jobs |
| Roo Code | Base agent (IDE) | multi-mode + Boomerang | discontinued → Zoo/Kilo |
Which should I use? — tap your situation
For the non-tech learner
A quick decision helper built from the guide below. Remember they compose: BMAD/Superpowers run on top of a base agent; Cline and Zoo/Kilo are alternatives to Claude Code as the base.
How this connects to the course
From "using AI" to harness engineering.
Every framework above is just a packaged version of the seven harness layers you build by hand in Weekend 2 — the loop, tools, memory, observability, evals, guardrails, and orchestration. Because you'll have built them yourself, you can look at any framework and see what it's actually doing for you, judge whether its structure fits your project, and drive it well instead of trusting it blindly.
Where this sits in the series
Foundation (here) → Weekend 1 (build & ship) → Weekend 2 (wrap it in a harness) → frameworks (pick one deliberately). This page is the map so the rest has somewhere to land.
Map your own project (optional)
For the non-tech learner
Tie it to something real. Answer these three in your head (or on the printable worksheet) before Weekend 1.
Glossary & resources
Glossary
- Waterfall / Agile
- a one-pass linear process / a repeating short-cycle (sprint) process
- Sprint / Scrum / Kanban
- a short work cycle / sprint framework with roles / a continuous-flow board
- PM / BA / SA / QA
- Product-Project Manager / Business Analyst / Solution-System Architect / Quality Assurance
- DevOps
- joining development & operations to move software safely from laptop to users
- Environment
- a separate copy of the app: dev / test / staging / production
- CI/CD
- automatic build / test / deploy on every change
- Staging / UAT
- a production mirror for final checks / User Acceptance Testing
- Agent persona
- an AI agent given a specific role (Analyst, Architect, QA…), as in BMAD
- Orchestration / Boomerang
- coordinating multiple specialized agents; Roo/Zoo's orchestrator + sub-agents pattern
- Plan/Act
- Cline's two-phase workflow: plan, then execute with per-step approval
- TDD
- test-driven development — write the failing test first, then the code to pass it
Go deeper (official first)
A note on accuracy
This field changes monthly — versions, adoption numbers, pricing, and project status all move. Figures here are mid-2026 snapshots; re-check each project's official page before committing. Roo Code is discontinued — prefer Zoo Code, Kilo Code, or Cline.