AI Agent Development Team Framework ― Practical Scrum Automation with Claude Sub-Agents¶

1. Introduction: Transition to AI-First Scrum¶

In traditional Scrum development, humans performed all roles and spent significant time on routine tasks. In 2025, with the advent of Claude Code's Sub-Agent functionality, a new development paradigm becomes possible where AI agents can substitute these roles, allowing humans to focus on more strategic decision-making.

This article proposes a minimal framework with a 3-layer, 7-type agent configuration and explains its implementation methods and operational guidelines.

2. Framework Overview¶

2.1 Core Concepts¶

Minimize Human Roles: Focus only on approvals, direction corrections, and risk assessments
Autonomous Agent Coordination: Automatic collaboration between agents based on defined protocols
Metrics-Driven Improvement: Continuous measurement and automatic optimization

2.2 3-Layer Structure¶

graph TB
    subgraph "Direction & Improvement Layer"
        A[Strategy Agent]
        B[Flow Optimizer]
    end

    subgraph "Backlog Layer"
        C[Spec Curator]
    end

    subgraph "Implementation Layer"
        D[Dev-Frontend]
        E[Dev-Backend]
        F[Quality Guardian]
        G[Release Coordinator]
    end

    H[Librarian] --> A
    H --> B
    H --> C
    H --> D
    H --> E
    H --> F
    H --> G

    style H fill:#f9f,stroke:#333,stroke-width:4px

3. Detailed Agent Design¶

3.1 Agent Role Matrix¶

Layer	Agent	Key Functions	Traditional Role	Claude Sub-Agent Configuration
Direction & Improvement	Strategy Agent	OKR updates, hypothesis validation, roadmap adjustment	Product Owner	`name: strategy-agent` `tools: browser,llm` `prompt: Check business metrics weekly and update OKRs`
	Flow Optimizer	Bottleneck detection, process experiments, metrics visualization	Scrum Master	`name: flow-optimizer` `tools: git,analytics,llm` `prompt: Target CycleTime↑・DefectRate↓`
Backlog	Spec Curator	Requirements→User stories, prioritization, DoR/DoD management	PO Assistant/BA	`name: spec-curator` `tools: editor,llm` `prompt: Maintain requirements.md/decompose tasks.md`
Implementation	Dev-Frontend Dev-Backend	Code generation, unit testing, documentation	Developers	`name: dev-frontend` `tools: editor,test,llm`
	Quality Guardian	Static analysis, security, code reviews	QA/Reviewer	`name: quality-guardian` `tools: bash,test-runner`
	Release Coordinator	CI/CD execution, versioning, release notes	Release Manager	`name: release-coordinator` `tools: git,ci`
Cross-cutting	Librarian	Decision tracking, specification synchronization (SSOT)	Documentation Manager	`name: librarian` `tools: editor,llm`

3.2 Agent Definition Example¶

# .claude/agents/strategy-agent.yml
name: strategy-agent
description: Strategy Agent responsible for business strategy and OKR management
tools:
  - browser
  - llm
  - analytics-api
system_prompt: |
  You are a Strategy Agent managing business strategy.
  Execute the following tasks weekly:
  1. Retrieve latest business metrics from KPI dashboard
  2. Analyze goal achievement status and create OKR revision proposals
  3. Collect user feedback and validate value hypotheses
  4. Communicate next sprint priority proposals to Spec Curator
triggers:
  - cron: "0 9 * * MON"  # Every Monday at 9 AM
  - event: "okr-review-requested"

4. Weekly Iteration Cycle¶

4.1 Standard Weekly Flow¶

Day/Time	Activity	Responsible Agent	Human Involvement
Monday 09:00	Strategy Sync	Strategy Agent	OKR Approval
Monday 10:00	Backlog Refresh	Spec Curator	-
Tue-Thu	Development Phase	Dev Agents	-
Continuous	Quality Checks	Quality Guardian	-
Thursday 17:00	Demo & Review	Librarian	Functionality Check
Friday 10:00	Retrospective	Flow Optimizer	Improvement Approval

4.2 Automated Workflow Example¶

sequenceDiagram
    participant H as Human
    participant SA as Strategy Agent
    participant SC as Spec Curator
    participant DA as Dev Agents
    participant QG as Quality Guardian
    participant RC as Release Coordinator

    Note over SA: Monday 09:00
    SA->>H: Present OKR revision proposal
    H->>SA: Approval
    SA->>SC: Instruct priority updates

    Note over SC: Monday 10:00
    SC->>SC: Update requirements.md
    SC->>SC: Regenerate tasks.md
    SC->>DA: Assign tasks

    Note over DA: Tue-Thu
    loop Development Cycle
        DA->>DA: Generate code
        DA->>QG: Commit hook
        QG->>DA: Review results
        DA->>RC: Staging deployment
    end

5. Implementation Guide¶

5.1 Starting with Minimal Configuration¶

Prepare Spec-Driven Repository

# Use Kiro template (recommended)
kiro init my-project --template=spec-driven

# Or create manually
mkdir -p .claude/agents
touch requirements.md design.md tasks.md

Define Initial 3 Agents

# .claude/agents/minimal-setup.yml
agents:
  - strategy-agent    # Strategy management
  - spec-curator      # Specification management  
  - dev-generalist    # General development

Gradual Expansion Criteria
Cycle Time > 3 days → Add flow-optimizer
Defect Rate > 5% → Add quality-guardian
Release frequency > 2 times/week → Add release-coordinator

5.2 Quality Gate Implementation with Hooks¶

# .claude/hooks/quality-gates.yml
hooks:
  pre-commit:
    - name: spec-code-sync
      command: |
        # Check spec-code differences
        claude-agent run librarian --check-sync

  post-merge:
    - name: update-metrics
      command: |
        # Update metrics
        claude-agent run flow-optimizer --update-dashboard

5.3 Metrics Configuration Example¶

# .claude/metrics.yml
metrics:
  cycle_time:
    target: < 2 days
    measure: commit_to_deploy

  defect_escape_rate:
    target: < 3%
    measure: production_bugs / total_stories

  spec_coverage:
    target: > 95%
    measure: documented_features / total_features

6. Practical Insights and Recommendations¶

6.1 Framework Advantages¶

Reduced Cognitive Load
Humans focus only on strategic decisions
Liberation from routine tasks
24/7 Development Cycle
Agents can work continuously
Development independent of time zones
Improved Consistency
Process standardization
Elimination of personal dependencies

6.2 Implementation Challenges and Solutions¶

Challenge	Solution
Agent runaway	Restrict permissions to minimum, implement approval flows
Context loss	Centralized knowledge management by Librarian
Quality instability	Gradual strengthening of Quality Guardian
Team culture change	Clarify and educate new human roles

6.3 Governance and Risk Management¶

# .claude/governance.yml
policies:
  approval_required:
    - production_deployment
    - okr_changes
    - architecture_decisions

  agent_restrictions:
    dev-agents:
      - no_production_access
      - no_credential_access

  audit_trail:
    - all_agent_actions
    - decision_rationale

7. Future Prospects and Extensibility¶

7.1 Evolution to Next Generation¶

Advanced multi-agent coordination
Introduction of self-improving agents
Addition of domain-specific agents

7.2 Integration with Other Tools¶

graph LR
    A[Claude Sub-Agents] --> B[GitHub Actions]
    A --> C[Jira/Linear]
    A --> D[Slack/Discord]
    A --> E[Monitoring Tools]

    B --> F[Automated Deployment]
    C --> G[Task Tracking]
    D --> H[Team Communication]
    E --> I[Performance Analytics]

8. Conclusion¶

The AI agent development team framework using Claude Sub-Agents fundamentally redefines traditional Scrum development. It creates an environment where humans can focus on the creative decision-making they should prioritize, enabling both development efficiency and quality.

Implementation Key Points¶

Start with minimal configuration: Begin with 3 agents
Metrics-driven: Gradual expansion based on data
Redefine human roles: Focus on approval and strategic decisions
Continuous improvement: Optimization by agents themselves

While this framework is still conceptual, it represents an important step toward shaping a new development culture in the AI era. It's crucial to refine it together with the community as implementation progresses.