Understanding the Agentic-SWE Structured Software Engineering Pipeline

The agentic-swe structured software engineering pipeline transforms standard Claude Code sessions into self-contained, rigorous development workflows by combining declarative markdown policies, slash commands, and 135+ specialist sub-agents to enforce engineering standards without external CI/CD infrastructure.

The agentic-swe structured software engineering pipeline is an open-source plugin distributed through the anthropics/claude-plugins-community repository. Unlike traditional DevOps toolchains that require separate runtime environments, this pipeline embeds directly into Claude Code via session hooks and version-controlled policy files, orchestrating the complete software lifecycle—from requirements clarification through deployment—while maintaining immutable audit trails.

Core Architecture of the Agentic-SWE Pipeline

The pipeline's architecture rests on three foundational pillars documented in anthropics/claude-plugins-community/.claude-plugin/marketplace.json and implemented in the source repository at github.com/surajSFDC/agentic-swe.

Markdown Policies and Phase Prompts

Declarative policies serve as the pipeline's cognitive layer, initialized at session start to enforce disciplined engineering practices. These policies—defined in files such as CLAUDE.md—establish non-negotiable rules like "no ambiguous code" and provide pre-written prompts that guide the agent through sequential development phases. According to the plugin manifest at .claude-plugin/marketplace.json#L734-L741, these policies inject automatically via session hooks the moment the plugin loads, ensuring every subsequent interaction conforms to the structured workflow.

Slash Commands and File Templates

Users navigate phase transitions through slash commands that trigger specific pipeline stages. Critical commands include:

• /install — Safely merges the plugin's CLAUDE.md and .worklogs/ templates into the target repository
• /lp-kickoff — Initializes a new pipeline session with selectable rigor tracks
• /review — Activates the code review phase with specialist agents

These commands leverage file templates to establish the .worklogs/ directory structure, ensuring that every artefact required for downstream gates is captured in a standardized format.

Specialist Sub-Agents

The pipeline activates 135+ domain-specific sub-agents on demand, including dedicated "code-reviewer", "test-generator", and "security-scanner" agents. Each sub-agent produces timestamped outputs stored under .worklogs/<id>/, creating an evidence-friendly audit trail where every decision—from design approvals to security clearances—links to concrete, reproducible artefacts.

Pipeline Tracks for Risk-Based Governance

The agentic-swe structured software engineering pipeline supports three distinct rigor levels defined in the marketplace configuration, allowing teams to calibrate process overhead against change risk.

Lean Track

Designed for small, low-risk changes such as typo fixes or documentation updates. This track employs minimal human gates and prioritizes rapid iteration over comprehensive documentation.

Standard Track

Intended for typical feature development. This track enforces standard ambiguity resolution checks and approval gates while maintaining the full .worklogs/ artefact structure for traceability.

Rigorous Track

Reserved for high-impact or production-critical changes. This track mandates all human gates, requires thorough testing with complete coverage reports, and enforces a full audit trail within .worklogs/<id>/. Activate this track using /lp-kickoff --track rigorous.

Human Gates and Evidence-Friendly Artefacts

At strategic pipeline checkpoints—such as post-design or pre-merge—the workflow inserts human gates for ambiguity resolution and formal approval. The /approve --gate human command triggers these mandatory checkpoints, persisting the outcome as markdown files in .worklogs/<id>/. This evidence-friendly structure ensures every architectural decision is backed by design sketches, test results, or review comments, satisfying audit requirements without external ticketing systems.

Installation and Session Initialization

The /install command safely integrates the plugin's policies into the target codebase, ensuring that CLAUDE.md and .worklogs/ templates are version-controlled alongside the source code. Once loaded, session hooks inject the markdown policies immediately, guaranteeing that Claude respects the pipeline rules from the first prompt. This self-contained approach ensures that engineering standards travel with the repository rather than residing in external configuration.

Practical Workflow Example

The following sequence demonstrates a complete rigorous development cycle using the agentic-swe structured software engineering pipeline:

# Initialize a rigorous pipeline with full audit requirements

/lp-kickoff --track rigorous

# Trigger the design review sub-agent

/design-review

# Generate unit tests automatically using the pytest framework

/generate-tests --framework pytest

# Execute the test suite and persist structured results

/run-tests --save .worklogs/1234/test-report.md

# Submit the complete artefact package for human approval

/approve --gate human

Each command invokes the corresponding specialist sub-agent, populates .worklogs/ with traceable artefacts, and enforces the appropriate human gates for the selected track.

Summary

• The agentic-swe structured software engineering pipeline operates entirely within Claude Code through the anthropics/claude-plugins-community plugin ecosystem, requiring no external runtime.
• Three core components—Markdown Policies, Slash Commands, and 135+ Specialist Sub-Agents—orchestrate the complete development lifecycle from kickoff to deployment.
• Three pipeline tracks (Lean, Standard, Rigorous) enable risk-based governance that matches process overhead to change criticality.
• The .worklogs/<id>/ directory structure captures evidence-friendly artefacts at every human gate, creating immutable audit trails.
• Session hooks automatically inject discipline upon plugin load, while /install ensures policies remain version-controlled and portable across repositories.

Frequently Asked Questions

What is the agentic-swe structured software engineering pipeline?

The agentic-swe structured software engineering pipeline is a Claude Code plugin that converts AI-assisted coding sessions into disciplined software engineering workflows. It uses declarative markdown policies, slash commands, and specialist sub-agents to enforce standards like human approval gates and evidence collection without requiring separate CI/CD infrastructure. The plugin is registered in anthropics/claude-plugins-community/.claude-plugin/marketplace.json and maintained at github.com/surajSFDC/agentic-swe.

How do the three pipeline tracks differ?

The Lean track minimizes overhead for typo fixes and small changes with reduced human gates. The Standard track enforces typical ambiguity checks and approvals for feature work. The Rigorous track mandates all human gates, comprehensive testing, and full audit trails for production-critical changes. Users select tracks via /lp-kickoff --track, with the plugin adjusting gate requirements and artefact generation accordingly.

Where does the pipeline store evidence and audit trails?

All artefacts are stored in the .worklogs/<id>/ directory within the repository root. Every sub-agent output—from design sketches to security scan results—writes timestamped markdown files to this location. Commands like /run-tests --save .worklogs/1234/test-report.md and /approve automatically populate this directory, creating an immutable record that satisfies compliance and review requirements.

How does the plugin integrate with existing repositories?

The /install command safely merges the plugin's CLAUDE.md policy file and .worklogs/ directory templates into the target repository. This ensures that pipeline policies are version-controlled alongside the codebase, while session hooks guarantee that Claude respects these rules immediately upon loading the plugin, creating a self-contained engineering environment that travels with the code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}