Sadd

Sadd

Dispatches independent subagents for individual tasks with code review checkpoints between iterations for rapid, controlled development

Category: development Source: NeoLabHQ/context-engineering-kit

What Is This?

Overview

SADD, which stands for Subagent-Driven Development, is a development methodology and toolset from the NeoLabHQ context-engineering-kit that dispatches independent subagents to handle individual tasks within a larger development workflow. Each subagent operates on a scoped unit of work, such as writing a function, generating tests, or refactoring a module, and the system enforces code review checkpoints between iterations to maintain quality and control throughout the process.

The core principle behind SADD is parallelism with accountability. Rather than relying on a single monolithic agent to handle an entire codebase transformation, SADD breaks the work into discrete, reviewable units. Each subagent completes its assigned task, submits output for review, and only after approval does the next iteration proceed. This creates a controlled pipeline that mirrors professional software development practices, where peer review gates progression.

This approach is particularly valuable in rapid development contexts where speed must be balanced against correctness. By combining autonomous execution with structured checkpoints, SADD enables teams and individual developers to move quickly without sacrificing the oversight that prevents compounding errors across a codebase.

Who Should Use This

  • Software engineers who want to accelerate feature development while maintaining code quality standards through automated review gates
  • Technical leads managing complex refactoring projects who need parallel task execution without losing visibility into each change
  • AI-assisted development teams integrating large language model workflows into their CI/CD pipelines
  • Developers building context-engineering systems who need a structured framework for multi-agent task orchestration
  • Researchers and practitioners exploring agentic software development patterns and subagent coordination strategies
  • Platform engineers who need repeatable, auditable development workflows for compliance-sensitive environments

Why Use SADD?

Problems It Solves

SADD addresses the problem of uncontrolled agentic sprawl, where a single agent makes cascading changes across a codebase without checkpoints, making errors difficult to trace and reverse. It also solves the bottleneck of sequential task execution by dispatching subagents in parallel, reducing total development time for multi-component features. Additionally, it eliminates the lack of accountability in automated code generation by enforcing review gates that require explicit approval before proceeding to the next iteration.

Core Highlights

  • Dispatches independent subagents per task, enabling parallel execution across multiple code units
  • Enforces code review checkpoints between each iteration to prevent error propagation
  • Scopes each subagent to a single responsibility, reducing context contamination between tasks
  • Supports rapid iteration cycles without sacrificing review discipline
  • Integrates with context-engineering workflows for structured prompt and task management
  • Provides a reproducible development pipeline suitable for team environments
  • Enables granular rollback by isolating changes to individual subagent outputs
  • Compatible with standard version control workflows for diff-based review

How to Use SADD?

Basic Usage

To initialize a SADD workflow, define your task manifest and dispatch subagents using the context-engineering-kit CLI:

sadd init --project my-feature --tasks tasks.yaml
sadd dispatch --agent write_function --context context/auth.md
sadd review --checkpoint 1 --approve
sadd dispatch --agent write_tests --context context/auth.md

Each dispatch command sends a scoped subagent to complete one task. The review command halts progression until the checkpoint is explicitly approved or rejected.

Specific Scenarios

For a feature involving a new API endpoint, you would dispatch one subagent to write the route handler, a second to generate input validation logic, and a third to produce integration tests. Each subagent receives only the context relevant to its task, preventing cross-contamination.

For a refactoring project, dispatch subagents to individual modules in parallel. Each subagent receives the module file and a refactoring specification. After each checkpoint review, approved changes are merged before the next module batch is dispatched.

Real-World Examples

A team migrating from REST to GraphQL can dispatch subagents per resolver, reviewing each before proceeding to schema stitching. A solo developer building a CLI tool can use SADD to generate command handlers independently, reviewing each before wiring them into the main entry point.

When to Use SADD?

Use Cases

  • Building multi-component features where parallel task execution reduces delivery time
  • Conducting large-scale refactoring with isolated, reviewable changes per module
  • Generating test suites alongside implementation code using separate subagents
  • Automating boilerplate generation with quality gates before integration
  • Running compliance-sensitive development workflows that require audit trails
  • Prototyping new features rapidly while maintaining structured review discipline
  • Coordinating multi-agent pipelines in context-engineering research projects

Important Notes

Requirements

  • NeoLabHQ context-engineering-kit installed and configured in your environment
  • A task manifest file defining subagent scopes and context references
  • Access to a compatible language model API for subagent execution