Skip to content

Agentic Software Development

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.

  1. 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.
  2. Part 2 — Day-One Guardrails: Sandboxes, Secret Hygiene, and Safe Agent Permissions (Foundations)
    The Day-1 checklist for small teams: filesystem sandboxes, .env and 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.

  1. Part 3 — Writing Your First AGENTS.md (Without Triggering Context Rot) (Context & Specifications)
    How to write a crisp, vendor-neutral root AGENTS.md under 120 lines—and avoid turning it into an 800-line instruction museum agents ignore.
  2. 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.
  3. Part 5 — Skills vs. MCP: When to Write a Markdown Runbook vs. Build a Tool Server (Context & Specifications)
    Drawing a clean boundary between procedural SKILL.md runbooks and typed Model Context Protocol tool servers.
  4. 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.

  1. 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 with CODEOWNERS.
  2. 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.

  1. Part 9 — Parallel Agents Without Merge Hell: Git Worktrees and Specialized Subagents (Workflows & Fleets)
    Isolating concurrent tasks in sibling git worktree checkouts, avoiding shared-port collisions, and splitting Researcher, Builder, and Adversarial Verifier roles.
  2. 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