DevForge AI

Optimised SDLC AI workflow — 10 role-specific agents × 5 phases with tracer bullet delivery and self-correction loops

An agentic SDLC orchestration system for Claude Code. DevForge AI turns an idea into a planned, built, verified, shipped, and operated feature using role-specific agents, tracer bullet slices, quality gates, and handoff documents.

This is not a one-shot code generator. DevForge AI is a delivery workflow: product thinking first, thin vertical slices, feedback loops, security and performance checks, deployment assets, and operational follow-through.

Quickstart

1. Install the package:

sudo npm install -g devforge-ai

1. Install the DevForge AI agents, skills, commands, and integrations into Claude Code:

devforge-ai install

1. Restart Claude Code, then run the full pipeline:

/sdlc "build a login page"

1. Or run one phase at a time:

/sdlc-plan "add OAuth login"
/sdlc-build
/sdlc-verify
/sdlc-ship
/sdlc-operate

System Architecture

graph TD
    classDef orchestrator fill:#1e293b,stroke:#64748b,stroke-width:2px,color:#f8fafc;
    classDef phase fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#f8fafc;
    classDef agent fill:#172554,stroke:#60a5fa,stroke-width:1px,color:#f8fafc;
    classDef artifact fill:#14532d,stroke:#4ade80,stroke-width:1px,color:#f8fafc;
    classDef skill fill:#581c87,stroke:#c084fc,stroke-width:1px,color:#f8fafc;
    classDef integration fill:#701a75,stroke:#f0abfc,stroke-width:1px,color:#f8fafc;

    User([User / Developer]) -->|Execute /sdlc or Phase Commands| Orchestrator["/sdlc Orchestrator & CLI"]:::orchestrator

    subgraph SDLC_Pipeline ["DevForge AI 5-Phase SDLC Pipeline"]
        direction TB

        subgraph Phase1 ["1. PLAN Phase (/sdlc-plan)"]
            P1_Cmd["/sdlc-plan"]:::phase
            P1_Agent["product-manager"]:::agent
            P1_Art1["grill-summary.md"]:::artifact
            P1_Art2["scope.json"]:::artifact
            P1_Art3["01-prd.md"]:::artifact
            
            P1_Cmd --> P1_Agent
            P1_Agent --> P1_Art1
            P1_Agent --> P1_Art2
            P1_Agent --> P1_Art3
        end

        subgraph Phase2 ["2. BUILD Phase (/sdlc-build)"]
            P2_Cmd["/sdlc-build / /sdlc-implement"]:::phase
            P2_A1["ux-designer (if has_ui)"]:::agent
            P2_A2["fullstack-engineer"]:::agent
            P2_A3["qa-engineer"]:::agent
            P2_Art1["ux-design.md"]:::artifact
            P2_Art2["Code & Tests"]:::artifact
            P2_Art3["implementation-log.md"]:::artifact
            
            P2_Cmd --> P2_A1 & P2_A2 & P2_A3
            P2_A1 --> P2_Art1
            P2_A2 --> P2_Art2
            P2_A2 --> P2_Art3
            P2_A3 --> P2_Art2
        end

        subgraph Phase3 ["3. VERIFY Phase (/sdlc-verify)"]
            P3_Cmd["/sdlc-verify"]:::phase
            P3_A1["security-engineer"]:::agent
            P3_A2["performance-engineer (gated)"]:::agent
            P3_Art1["security-report.md"]:::artifact
            P3_Art2["performance-report.md"]:::artifact
            
            P3_Cmd --> P3_A1 & P3_A2
            P3_A1 --> P3_Art1
            P3_A2 --> P3_Art2
        end

        subgraph Phase4 ["4. SHIP Phase (/sdlc-ship)"]
            P4_Cmd["/sdlc-ship"]:::phase
            P4_A1["devops-engineer"]:::agent
            P4_Art1["CI/CD, Docker, K8s, Release Notes"]:::artifact
            
            P4_Cmd --> P4_A1
            P4_A1 --> P4_Art1
        end

        subgraph Phase5 ["5. OPERATE Phase (/sdlc-operate)"]
            P5_Cmd["/sdlc-operate"]:::phase
            P5_A1["sre-engineer"]:::agent
            P5_A2["data-engineer (gated)"]:::agent
            P5_Art1["06-slo.md, Runbooks, Dashboards"]:::artifact
            
            P5_Cmd --> P5_A1 & P5_A2
            P5_A1 & P5_A2 --> P5_Art1
        end
    end

    Orchestrator --> P1_Cmd
    Phase1 -->|plan-handoff.md| Phase2
    Phase2 -->|build-handoff.md| Phase3
    Phase3 -->|verify-handoff.md| Phase4
    Phase4 -->|ship-handoff.md| Phase5

    subgraph Core_Mechanisms ["Core Capabilities & Integrations"]
        RalphLoop["Ralph Loop Self-Correction Engine"]:::skill
        LinearInt["Linear Integration (Issues & Tracking)"]:::integration
        GraphInt["code-review-graph Integration"]:::integration
        SkillsLib["34 Knowledge Skills (grill-me, TDD, OWASP, SRE...)"]:::skill
    end

    Phase2 <--> RalphLoop
    Phase1 <--> LinearInt
    Phase2 <--> GraphInt
    SDLC_Pipeline <.-> SkillsLib

Install From Source

git clone https://github.com/saitarrun/devforge-ai
cd devforge-ai
npm install
npm run install-local

Restart Claude Code after installing. See INSTALLATION.md for update, symlink, and uninstall instructions.

Why DevForge AI Exists

DevForge AI is built around the common places AI-assisted engineering breaks down.

1. The Agent Builds The Wrong Thing

The first failure mode is misalignment. A feature request sounds obvious until the agent fills in the wrong blanks.

DevForge AI starts with /sdlc-plan, where the product-manager agent runs a structured interview, writes grill-summary.md, produces scope.json, synthesizes a PRD, and creates implementation issues. The result is a concrete build plan before any code is written.

Use this when:

• The idea is still fuzzy
• You need user stories and acceptance criteria
• You want vertical slices instead of a giant implementation blob
• You want requirements captured as artifacts, not lost in chat history

2. The Work Is Too Big To Trust

Large agent tasks fail because the feedback loop is too slow. DevForge AI breaks features into tracer bullet slices: thin increments that cut through schema, API, UI, and tests where needed.

Each slice is tracked in scope.json:

{
  "capability_flags": {
    "has_ui": true,
    "has_auth": true
  },
  "slices": [
    {
      "id": "slice-0",
      "name": "Project scaffold + health check",
      "type": "prefactor",
      "layers": ["schema", "api", "tests"]
    },
    {
      "id": "slice-1",
      "name": "User can log in",
      "type": "feature",
      "layers": ["schema", "api", "ui", "tests"]
    }
  ]
}

The first slice establishes the foundation. Every later slice delivers one user-visible increment and appends its result to implementation-log.md.

3. The Code Does Not Work

DevForge AI uses the Ralph Loop during build work:

• Implement one slice
• Run the relevant type checks and tests
• Retry with fresh context when verification fails
• Stop at a circuit breaker instead of looping silently
• Run cross-slice QA after feature slices are complete

This gives the agent a disciplined feedback loop instead of relying on confidence.

4. The Process Loses Context

Long SDLC sessions can drown the model in stale conversation history. DevForge AI uses handoff documents at phase gates:

plan-handoff.md   -> /sdlc-build
build-handoff.md  -> /sdlc-verify
verify-handoff.md -> /sdlc-ship
ship-handoff.md   -> /sdlc-operate

Each phase reads the handoff first, then starts with bounded context. Decisions survive, but unnecessary chat history does not.

5. Shipping Is Not The End

DevForge AI includes verification, deployment, and operations phases. The workflow does not stop when code compiles.

The later phases cover:

• Security review and OWASP checks
• Performance profiling when required
• CI/CD, Docker, Kubernetes, and infrastructure artifacts
• SLOs, monitoring, runbooks, and operational readiness
• Data pipeline planning when the feature needs it

How The Pipeline Works

Some agents are scope-gated:

• ux-designer runs when has_ui is true
• performance-engineer runs when needs_performance_audit is true
• data-engineer runs when has_data_pipeline is true
• Security monitoring is added when has_auth is true

Project Artifacts

Every SDLC run writes into a project folder:

./projects/<feature-name>/
  grill-summary.md
  scope.json
  docs/
    01-prd.md
    ux-design.md
    implementation-log.md
    security-report.md
    performance-report.md
    05-pipeline.log
    06-slo.md
  handoffs/
    plan-handoff.md
    build-handoff.md
    verify-handoff.md
    ship-handoff.md

Reference

DevForge AI is split into commands, agents, and skills.

Commands are what you type. Agents are the role-specific workers. Skills are methodology documents that agents load when their task needs that discipline.

Commands

• /sdlc - Master orchestrator for the full Plan -> Build -> Verify -> Ship -> Operate pipeline.
• /sdlc-plan - Product planning, interview, PRD, scope, and issues.
• /sdlc-build - UX design, slice implementation, Ralph Loop retries, and QA.
• /sdlc-verify - Security and performance verification.
• /sdlc-ship - CI/CD, cloud infrastructure, containerization, and release.
• /sdlc-operate - SLOs, runbooks, monitoring, and data pipelines.
• /sdlc-implement - Standalone issue or free-form implementation with Ralph Loop verification.
• /sdlc-review - Pull request review using parallel reviewer perspectives.
• /to-prd - Regenerate a PRD from existing planning artifacts.
• /to-issues - Create one issue per tracer bullet slice from scope.json.

Agents

• product-manager - Runs the planning interview, decomposes features, writes scope.json, and drives PRD and issue creation.
• ux-designer - Produces wireframes, design tokens, component specs, and interaction states when the feature has UI.
• fullstack-engineer - Implements vertical slices across schema, API, UI, and tests.
• qa-engineer - Writes and runs cross-slice E2E tests after implementation.
• security-engineer - Performs SAST, OWASP, dependency scanning, and pentest work when required.
• performance-engineer - Profiles bottlenecks, validates performance budgets, and recommends optimizations.
• devops-engineer - Builds CI/CD, Docker, Kubernetes, Terraform, and release procedures.
• sre-engineer - Defines SLOs, dashboards, alerts, runbooks, and security operations.
• data-engineer - Designs ETL/ELT pipelines, analytics schemas, schedules, and data quality checks.
• technical-writer - Produces API docs, guides, tutorials, and developer-facing documentation.

Core Skills

These are the skills most central to the DevForge AI pipeline:

• grill-me - Structured interrogation before planning.
• requirements - User stories, acceptance criteria, ambiguity checks, and INVEST-style decomposition.
• prd-synthesis - Converts context into product requirements.
• to-prd - Synthesizes PRDs from current context and planning artifacts.
• to-issues - Converts plans into independently-grabbable issues.
• plan-breakdown - Breaks work into implementation slices.
• ralph-loop - Self-correcting build loop with retries and circuit breakers.
• handoff - Compacts phase context into handoff documents.
• ux-design - UX design discipline for UI-bearing features.
• prototype - Throwaway prototypes for UI or state-model exploration.
• tdd - Red-green-refactor test-driven development.
• testing - Test strategy and coverage discipline.
• playwright - Browser automation and E2E testing.

Engineering Skills

• architecture - System design, ADRs, coupling, service boundaries, and tradeoffs.
• architecture-refactor - Finds architecture improvement opportunities.
• api-design - API contracts, OpenAPI, versioning, error design, and compatibility.
• code-quality - Linting, tests, coverage, security checks, and CI guardrails.
• code-standards - Naming, structure, maintainability, and implementation conventions.
• code-review - Review discipline for correctness and maintainability.
• pr-review - Pull request review patterns.
• diagnose - Reproduce, minimize, hypothesize, instrument, fix, and regression-test.
• zoom-out - Higher-level context when the codebase shape is unclear.
• dependency-management - Version updates, CVEs, licenses, and transitive dependencies.
• configuration-management - Secrets, environment config, feature flags, and auditability.
• documentation - Docs-as-code, examples, tutorials, and API docs.
• write-skill - Guidance for authoring new skills.

Security, Delivery, And Operations Skills

• security-audit - Security review, OWASP checks, and vulnerability scanning.
• threat-modeling - STRIDE and attack-surface analysis.
• performance-optimization - Profiling, benchmarking, and performance budgets.
• observability - Metrics, logs, traces, dashboards, alerts, and SLOs.
• cicd - CI/CD pipeline design.
• cloud-infra - Cloud infrastructure, networking, compute, and managed services.
• precommit-hooks - Husky, lint-staged, formatting, type checks, and test hooks.
• git-safety - Git guardrails for destructive commands.
• ops-sre - SRE practices, runbooks, incidents, and reliability operations.
• issue-triage - Issue workflow and triage state management.

Development

Validate the plugin structure:

npm run validate

Install locally while developing:

npm run install-local

Uninstall local files:

npm run uninstall

Check the npm package contents:

npm pack --dry-run

Built On

• Tracer bullet development
• Red-green-refactor feedback loops
• Handoff-bounded context windows
• Product requirements before implementation
• Security and performance checks before shipping
• SLO-driven operations after release

License

Apache 2.0