cwijayasundara

Code generation quality principles — TDD, typing, error handling, logging, API integration, LLM integration.

Use when creating or editing .claude/agents/*.md, .claude/skills/*/SKILL.md, or .claude/commands/* — apply docs/prompting-standards.md (trigger conditions, model-agnostic bodies, no reasoning-as-text, effort floors).

Autonomous build loop with Karpathy ratcheting, GAN evaluator, and session chaining. Iterates story groups until all features pass or stopping criteria met.

Review this harness's own recent loop-health signals and recommend scored, evidence-backed improvements to the harness itself (skills, gates, sensors, CLAUDE.md rules) — never to product code. Use after a `/auto`/`/gate` run, on a drift cadence, or on demand…

Generate a per-commit, durable compliance attestation (with a sha256 corruption-detecting integrity checksum) from the harness control inventory, the branch-protection/deploy-gate verify outputs, the gate verdict, and the ratchet baselines — then commit the…

Aggregate per-repo compliance attestations into one integrity-hashed portfolio rollup — verifying each attestation's sha256 integrity, recording an unattested repo as a compliance gap, and computing harness-version drift across the fleet. Use over a local…

Provision the GitHub security-compliance gates and verify they hold. Three modes — protection (branch-protection ruleset so gitleaks+sast+code-owner review block merges), environments (deploy-approval environment so a deploy pauses for a required reviewer),…

Change the behavior of existing code — story-driven by default, or --issue N for a GitHub bug fix. Test-first, full verification, code review.

Discover and map an existing codebase before planning or changing it.

Change the behavior of existing code — story-driven by default, or --issue N for a GitHub bug fix. Test-first, full verification, code review.

Use when a planned change touches persisted data shape — ORM models, migration files, schema definitions, serialized formats, or message contracts — in /change, /refactor, or /implement on an existing codebase. Routes schema changes through expand-contract…

Generate production code and tests for a story group using agent teams for parallel execution.

Refactor existing code for quality, performance, or maintainability. Enforces core quality principles with ratchet gate.

Generate test plan, test cases, test data fixtures, and Playwright E2E tests mapped to acceptance criteria.

Use when bumping a dependency version — package.json, pyproject.toml, requirements, or lockfile changes — in an existing codebase. Classifies the bump, audits the usage surface from the code graph, and isolates the upgrade in its own proven commit.

Controlled small-change lane for low-risk fixes, docs, tests, and narrowly scoped edits without running the full SDLC pipeline.

Autonomous build loop with Karpathy ratcheting, GAN evaluator, and session chaining. Iterates story groups until all features pass or stopping criteria met.

Socratic interview to create a Business Requirements Document. First step in the SDLC pipeline.

Generate system architecture, machine-readable schemas, and UI mockups. Spawns planner + ui-designer concurrently.

Evaluation patterns — sprint contract format, three-layer verification, scoring rubric references.

Standard GitHub issue workflow. Branch, reproduce, fix, test, PR.

Generate production code and tests for a story group using agent teams for parallel execution.

Refactor existing code for quality, performance, or maintainability. Enforces six quality principles with ratchet gate.

Code generation quality principles — TDD, typing, error handling, logging, API integration, LLM integration.

Design the system architecture including layered dependencies, API contracts (endpoints, schemas, errors), data models, folder structure, and deployment topology. Output a detailed design document to `specs/design/` with all decisions justified.

Run the complete SDLC pipeline from BRD to deployed application. Orchestrates spec writing, architecture, UI design, implementation, code review, E2E testing, deployment, and PR creation.

Story-driven code generation with strict quality principles. Use when implementing user stories, writing production code, creating unit tests, or generating code from specs. Enforces small modules, static typing, 50-line function limit, and 100% meaningful…

Set up local development with Docker Compose, hot reload, health checks, and database migrations. Generate docker-compose.yml, Dockerfiles, .env.example, and document the deployment topology.

Run code review and security review on implemented code. Checks architecture compliance, quality principles, test coverage, and security vulnerabilities.

Test planning, test case design, test data generation, and Playwright E2E automation. Use when creating test plans, writing test cases, generating test data, setting up Playwright, or automating end-to-end tests.

Autonomous build loop with ratcheting. Implements stories iteratively — keep on pass, revert on fail, learn from failures. Runs until all stories pass or stopping criteria met.

Generate Docker Compose stack, Dockerfiles, env config, and verify local deployment with health checks and database migrations.

Use when editing a DeepAgents project — adding tools, sub-agents, modifying the system prompt, choosing a filesystem backend, or composing extra middlewares (retries, fallbacks, HITL) on top.

Use when creating a new LangChain / LangGraph / DeepAgents project from scratch. Picks the right scaffolder for graphs vs. DeepAgents vs. LCEL chains.

Use when starting work on any LangChain / LangGraph / DeepAgents project. Entry point for the develop -> middleware -> evaluate -> deploy lifecycle, mapping each step to the right official tool.

Use when productionising or deploying a LangChain / LangGraph / DeepAgents agent. Covers durable execution (checkpointers, thread_id), the production middleware stack, three deploy targets (LangSmith Cloud, Cloud Run, Docker), secrets, scaling, and…

Use when editing a non-agentic LCEL pipeline — composing Runnables, retrievers, embeddings, chat models, parsers, or building a RAG chain. For agents (LLM + tools loop), use the middleware skill instead.

Use when building a custom-graph LangGraph agent — when `create_agent(...)` + middleware isn't enough and you need explicit StateGraph control (multi-graph workflows, custom routing, non-standard state schemas, parallel branches). For the common case, use…

Use when authoring eval datasets, writing evaluators, running evals against a LangChain / LangGraph / DeepAgents project, comparing eval results between runs, or writing unit/integration tests for an agent.

Use when building or productionising any agent — adding retries, fallbacks, summarization, human-in-the-loop, PII redaction, call limits, or custom hooks. Middleware is THE composition primitive for modern LangChain agents (v1+); covers built-ins plus the…

Autonomous build loop with Karpathy ratcheting, GAN evaluator, and session chaining. Iterates story groups until all features pass or stopping criteria met.

Socratic interview to create a Business Requirements Document. First step in the SDLC pipeline.

Generate system architecture, machine-readable schemas, and UI mockups. Spawns planner + ui-designer concurrently.

Evaluation patterns — sprint contract format, three-layer verification, scoring rubric references.

Standard GitHub issue workflow. Branch, reproduce, fix, test, PR.

Generate production code and tests for a story group using agent teams for parallel execution.

Refactor existing code for quality, performance, or maintainability. Enforces six quality principles with ratchet gate.

Use this skill when the task requires turning agent work into polished repository artifacts such as reports, design notes, and structured briefs without editing source code.

Use this skill when the user asks for a comparison, ecosystem analysis, or synthesis of open versus managed agent harnesses. It helps the agent gather sources, extract tradeoffs, and turn them into durable markdown artifacts.