sdlc multi agent harness

    1

    Deterministic SDLC Multi-Agent Harness (5-Role Pipeline + JSON Contracts)

    $29

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    sdlc multi agent harness

    Example session with this skill installed

    Build a secure Node.js Express microservice for user registration. Include JWT auth, a Postgres schema, unit tests, and a Dockerfile. Apply the full SDLC harness.

    • Read your context and instructions
    • Compiled the sdlc multi agent

    I have orchestrated the development of your User Registration Microservice. The Architect designed a layered service pattern, the Developer implemented the Express logic with bcrypt hashing, the QA Reviewer verified the JWT implementation, and DevOps provided the containerization.

    User Registration Microservice

    Architectural Overview

    • Pattern: Layered Architecture (Controller -> Service -> Repository)
    • Stack: Node.js, Express, PostgreSQL, Prisma ORM, Vitest
    • Security: Argon2 password hashing, JWT-based stateless authentication

    Directory Tree

    user-service/
    ├── src/
    │   ├── controllers/
    │   ├── services/
    │   ├── middleware/
    │   └── index.ts
    ├── tests/
    ├── prisma/
    │   └── schema.prisma
    ├── Dockerfile
    ├── docker-compose.yml
    └── README.md
    

    Source Code: Authentication Middleware

    import { Request, Response, NextFunction } from 'express';
    import jwt from 'jsonwebtoken';
    
    export const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
      const token = req.headers.authorization?.split(' ')[1];
      if (!token) return res.status(401).json({ error: 'Unauthorized' });
    
      try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET as string);
        (req as any).user = decoded;
        next();
      } catch (err) {
        res.status(401).json({ error: 'Invalid token' });
      }
    };
    

    Security Audit Summary

    • Status: PASSED

    Findings: Verified Argon2 implementation for password entropy. Confirmed JWT secret is pulled from environment variables.

    • Tests: 12 unit tests passed (100% coverage on auth logic).

    DevOps & Deployment

    FROM node:20-slim
    WORKDIR /app
    COPY package*.json ./
    RUN npm install
    COPY . .
    RUN npx prisma generate
    EXPOSE 3000
    CMD ["npm", "start"]
    

    Next steps

    1. Add your DATABASE_URL and JWT_SECRET to the .env file.
    2. Run docker-compose up --build to launch the service and database.
    3. Execute npm run test to verify the security suite in your environment.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Deterministic SDLC Multi-Agent Harness

    Transform your AI coding assistant into a deterministic, zero-trust software delivery pipeline. Deterministic SDLC Multi-Agent Harness coordinates 5 isolated specialist roles using formal JSON Schema contracts, Blind Security Auditing, and an automated Self-Healing Fix Loop.

    Built for Claude Code (sub-agents), Cursor, Windsurf, Codex CLI, Gemini CLI, Cline, and GitHub Copilot.


    Why It Outperforms Standard Prompts

    • 5 Isolated Specialist Roles (agents/*.md):
      1. Orchestrator: Extracts requirements, enforces context hygiene, and assembles the final deliverable without writing code directly.
      2. Architect: Produces a concrete tech stack, directory tree, data models, interface contracts, and security strategy—no "TBD" placeholders.
      3. Developer: Implements every file in the blueprint verbatim with explicit error handling and zero TODO / pass stubs.
      4. Blind QA & Security Reviewer: Audits code against OWASP Top 10 / CWE and generates runnable tests without seeing Developer notes.
      5. DevOps & Docs Engineer: Generates non-root multi-stage Dockerfile, docker-compose.yml, .env.example, and an accurate README.md.
    • True Blind Security Review: Strips all Architect and Developer reasoning before QA/AppSec auditing to eliminate confirmation bias.
    • 5 Formal JSON Schema Contracts (schemas/*.schema.json): Validates every internal delegation envelope and specialist output (HandoffEnvelope, ArchitectOutput, DeveloperOutput, QaSecurityOutput, DevOpsDocsOutput).
    • Self-Healing Fix Loop: Automatically routes critical and high security or contract defects back to the Developer for surgical patches (up to 2 iterations) before final delivery.
    • Minimum Context Rule: Sub-agents receive strictly the structured inputs required for their phase—never bloated chat histories.

    What’s Included in the Package

    • SKILL.md — Master Orchestrator pipeline, handoff rules, and context isolation protocol.
    • agents/architect.md — Principal Software & System Architect role specification.
    • agents/developer.md — Senior Full-Stack Software Engineer role specification.
    • agents/qa-security-reviewer.md — Principal QA Automation & AppSec Reviewer specification.
    • agents/devops-docs.md — Senior DevOps & Technical Writer specification.
    • schemas/*.schema.json — 5 JSON Schema (Draft 2020-12) contracts enforcing structured agent outputs.
    • examples/worked-microservice-example.md — End-to-end execution walkthrough showing JSON handoffs, a Blind Security Review catch (SEC-001, BUG-001), and a Self-Healing Fix Loop resolution.

    Quick Start

    1. Extract into your agent's skills directory (e.g., ~/.claude/skills/sdlc-multi-agent-harness/ or .claude/skills/sdlc-multi-agent-harness/), or load on-demand via Agensi MCP.
    2. Invoke with your project specification:
      • "Run sdlc-multi-agent-harness to architect, implement, security-audit, and containerize a rate-limited FastAPI microservice."

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Capped at 2 self-healing fix loops. Requires environment support for sub-agent tool calls or isolated context steps. Sub-agents cannot access external live internet resources directly.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Permissions

    Read Files
    Write Files
    Terminal / Shell
    Browser
    Environment Variables
    Network Access
    Listedtoday

    What's inside

    Frequently Asked Questions

    It solves the common issue of LLM-generated code lacking security audits or test coverage by enforcing a rigid five-role pipeline where code must pass independent QA and DevOps verification before delivery.

    The skill is framework-agnostic and works with any agent platform that supports tool-calling or multi-prompt orchestration; it includes standardized JSON schemas to govern these role transitions.

    You receive the complete orchestration logic, five specialized role definition files, the JSON handoff schemas, and a guide on how to implement the self-healing retry loop in your environment.

    The harness is designed for architectural design, core implementation, and verification; while it can refactor existing logic, it is optimized for creating modular microservices, APIs, and discrete features.

    The harness includes a 'blind review' protocol that strips developer context from the code before the QA agent audits it, preventing the agent from overlooking bugs due to 'intended' logic descriptions.

    The system is configured for two automatic self-healing iterations where QA failures are sent back for fixes; if issues persist beyond that, the harness escalates the logs to the user for manual intervention.

    New in Agents & Orchestration