cwijayasundara

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

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

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

Brownfield change route — take an existing-code feature request from intent to a reviewed PR, scaling from a single /change to an epic via /spec→/design→/auto. Linear-tracked, backed by a committed DeepWiki.

[Internal pipeline stage — run by /auto self-heal and /implement validation when lint/type error volume is high; invoke directly only as a power user.] Turn compiler/linter output into a sharded work queue; fix per package with optional adversarial review — no full monorepo suite mid-shard.

[Internal pipeline stage — run by /auto (follow with /gate); invoke directly only as a power user.] 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.

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).

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 and proves reversibility before any deploy.

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.

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 post-deploy verification.

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 `create_agent` first (see middleware skill).

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 custom middleware authoring API.

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.