Start Here: The Small-Team Curriculum
Welcome to Agentic Software Development, a structured 10-part tutorial series built for small engineering teams (3 to 10 developers) moving from ad-hoc chat prompting to reliable, production-grade agentic workflows.
Why This Series Exists
Most writing about AI coding agents falls into two extremes: breathless demos of throwaway weekend apps, or enterprise platform decks aimed at 500-person orgs. Small teams live in the gap between. You have real production databases, shared branches, limited review bandwidth, and zero patience for agents that rewrite working modules or game your test suite.
This blog is designed to be read in order from Module 1 through Module 10—either over four weekly team brown-bags or as an onboarding track for engineers adopting CLI and IDE coding agents on shared repositories.
Note
Reading Order Note: Blog feeds list newest posts at the top, so Part 10 sits at the top of the home feed while Part 1 sits at the bottom. Use this Start Here syllabus whenever you want the step-by-step sequence from Day 1 to Week 4.
Week 1: Foundations & Safe Setup
Start here before letting an agent touch a shared repository.
- Part 1 — Beyond Vibe Coding: The 5-Stage Roadmap to Agentic Software Engineering (Foundations)
Why copy-paste chat loops break down by day three—and how teams progress from inline autocomplete through repo-aware rules, spec-driven verification, and parallel worktree fleets. - Part 2 — Day-One Guardrails: Sandboxes, Secret Hygiene, and Safe Agent Permissions (Foundations)
The Day-1 checklist for small teams: filesystem sandboxes,.envand credential isolation, command allowlists, and branch protections that keep experiments safe.
Week 2: Context, Specs & Tool Boundaries
Once your sandbox is safe, stop repeating rules in chat and move operational knowledge into version-controlled artifacts.
- Part 3 — Writing Your First AGENTS.md (Without Triggering Context Rot) (Context & Specifications)
How to write a crisp, vendor-neutral rootAGENTS.mdunder 120 lines—and avoid turning it into an 800-line instruction museum agents ignore. - Part 4 — Spec-Driven Development: How a 30-Line Blueprint Stops Agent Scope Creep (Context & Specifications)
Using lightweight EARS requirements (When ... the system shall ...) and explicit out-of-scope lists before writing implementation code. - Part 5 — Skills vs. MCP: When to Write a Markdown Runbook vs. Build a Tool Server (Context & Specifications)
Drawing a clean boundary between proceduralSKILL.mdrunbooks and typed Model Context Protocol tool servers. - Part 6 — Context Engineering: Stopping Token Bloat and Mid-Session Amnesia (Context & Specifications)
Why 200k-token models still drift mid-session, how progressive disclosure and subagent isolation preserve working memory, and how externalizing docs into a Wikantik knowledge MCP replaces static prompt stuffing.
Week 3: Verification & Code Review Discipline
Faster code generation breaks small teams when verification and PR review turn into rubber stamps.
- Part 7 — Trust, Then Verify: Stopping Coding Agents from Gaming Your Tests (Verification & Guardrails)
Separating immutable Red-phase tests from Green-phase edits, enforcing complexity ratchets, and protecting golden fixtures withCODEOWNERS. - Part 8 — Reviewing Agent PRs at 3x Speed: Diff Budgets, Atomic Commits, and Human Checkpoints (Verification & Guardrails)
Capping diff sizes, separating mechanical refactors from behavior changes, and focusing senior review time on security and schema boundaries.
Week 4: Parallel Workflows & Team Rollout
Scale from one developer running one session to an aligned team shipping predictably.
- Part 9 — Parallel Agents Without Merge Hell: Git Worktrees and Specialized Subagents (Workflows & Fleets)
Isolating concurrent tasks in siblinggit worktreecheckouts, avoiding shared-port collisions, and splitting Researcher, Builder, and Adversarial Verifier roles. - Part 10 — Team Rollout Playbook: Shared Rules, Evals, and Token Budgets for Small Teams (Workflows & Fleets)
A 4-week adoption cadence for committing shared skills in Git, routing work across frontier and fast models, tracking token spend, and running lightweight regression evals.
Quick Map by Category & Reference Wiki
- Foundations: Mental models, maturity stages, and Day-1 security boundaries.
- Context & Specifications:
AGENTS.md, 30-line specs, Skills vs. MCP, and externalized wiki context. - Verification & Guardrails: Anti-test-gaming patterns, CI ratchets, and small-batch PR review.
- Workflows & Fleets:
git worktreeisolation, specialized subagents, and team governance. - Companion Reference Shelf on Wikantik: Explore the underlying architecture specs, playbooks, and decision logs in the Agentic Coding Hub and the Agentic Adoption Learning Path.