coding-agent-workflows

Index of this project's coding-practice rules — architecture, coding style, testing, security, git workflow, task management, context layering, anti-slop, performance, and language-specific rules. The thin always-on essentials live in .claude/rules/common/house-rules.md; the full per-topic detail ships under .claude/rules/reference/ and .claude/rules/<lang>/ and is read on demand. Invoke this skill when you need the project's standards for a task, then open the specific rule file it points to.

Thin methodology for end-to-end tests of critical user journeys — define journeys by risk, use semantic locators and condition-based waits, quarantine flaky tests with a tracked reason, and capture artifacts on failure. Use when adding or stabilizing E2E coverage; the e2e-runner agent applies it in depth.

Design rigorous evaluations and benchmarks for AI agents, developer tools, retrieval systems, and repository-scale automation. Covers task selection, contamination control, metric choice tied to engineering decisions, and statistical validity. Use when asked to design an eval/benchmark, critique an existing benchmark, choose metrics for an agent or RAG system, or decide whether a measured improvement is real. NOT for running an existing performance-benchmark suite or a per-feature acceptance checklist, or one-off model spot-checks.

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree one at a time. Use for ambiguous or complex collaborative specs before any code is written.

Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases. Use when parsing quizzes, forms, invoices, or documents with repeating structure and cost matters.

Review a repository for long-term architectural leverage rather than code quality — system structure, module boundaries, dependency graph, coupling, and drift. Produces a ranked set of highest-ROI improvements with evidence, effort, and risk. Use when asked to review the architecture, assess a codebase's structure/design, find where complexity is concentrated, or decide what to refactor next. NOT for style, naming, formatting, or line-level bugs (use a code-review skill for those).

Analyze a software system, AI pipeline, or research direction by surfacing its underlying structure — invariants, hidden abstractions, weak assumptions, and the single highest-leverage direction — rather than optimizing local implementations. Use when asked to step back and think about a system's design at a conceptual level, find leverage points, evaluate a research direction for compounding impact, or decide where to invest for the long term. NOT for reviewing a specific repo's architecture (use repo-architecture-review) or local code cleanup.

Structured brainstorming with research-driven exclusion zones and shape-uniqueness enforcement. Forces divergent thinking through volume and a hard constraint: no idea may take the same shape as any prior art or any earlier idea. Use when exploring solutions to a problem, designing features, or when the obvious approach might not be the best one.

Binary search for root cause: define a search space and a pass/fail oracle, then halve the space each step until the culprit commit, config key, or dependency is isolated. Works across git history, configuration, dependencies, or code modules.

Comprehensive security and quality review of uncommitted changes. Scans the diff for injection, hardcoded secrets, auth gaps, and correctness issues, reported by severity.

Structured debate and refinement. Independent advocates argue competing positions and trade-offs over divergent findings, then converge on a refined synthesis. Pairs with diverge.

Essence extraction via progressive compression. Chained compressors each halve the previous output while keeping what matters; what each layer drops reveals the priority hierarchy.

Multi-perspective divergent research. N independent agents with uncorrelated context explore a question from different angles, then synthesize into one analysis and PRD.

Prospective failure narratives. Independent agents each write a story from a future where the project failed for a different root cause, synthesized into a risk registry with severity ratings and mitigations.

Run the diverge → converge → premortem pipeline to produce a risk-annotated PRD

Build-order planning via competing sequencing strategies. Independent agents each propose a different build order for a chosen design, synthesized into a recommended plan with milestones, dependencies, and risks.

Map the tribal knowledge of a codebase into per-area COMPASS.md files — the why, the gotchas, and how each area connects — for existing repos and as they grow. Use when the user says "map this codebase", "generate compass files", "refresh the compass", or after a significant area changes.

Index of this project's coding-practice rules — architecture, coding style, testing, security, git workflow, task management, context layering, anti-slop, performance, and language-specific rules. The thin always-on essentials live in .claude/rules/common/house-rules.md; the full per-topic detail ships under .claude/rules/reference/ and .claude/rules/<lang>/ and is read on demand. Invoke this skill when you need the project's standards for a task, then open the specific rule file it points to.

Multi-model code review of uncommitted changes. Spawns parallel reviewers across providers (Anthropic reuse/quality/efficiency + Codex grounded review) so blind spots in one model are caught by another. Use after writing or modifying code, before opening a PR, or when /simplify alone feels insufficient. Codex consistently catches semantic bugs that pattern-matching reviewers miss, keep it in the loop on anything non-trivial.

LLM-judge slop & erosion scan of a diff, mirroring SlopCodeBench. Scores code on Erosion (verbosity, dead branches, redundant structure accumulated under iterative change) and Verbosity (unnecessary complexity), then reports per-category findings weighted toward code that EXTENDS existing modules. Use after iteratively extending existing code, before opening a PR on a non-greenfield change, when a module has grown across several requirement changes, or when the user says "slop check", "check for erosion", "is this over-engineered". Complements the review skill (correctness + reuse) — this lens is specifically the accumulated-cruft axis. Scans code, not prose; for AI-writing patterns in prose or docs use writing-voice.

Voice, structural, and anti-pattern rules for drafting and editing prose: articles, docs, blog posts, READMEs, and longer-form technical writing. Combines a slop guard against telltale AI writing patterns with positive craft defaults (sentence rhythm, declarative heads, concrete openings, pivoting closes). Activate whenever generating or revising prose of more than a few paragraphs. This is the prose/writing slop guard, not the code one; for code-erosion slop in a diff use slop-check.

Record a "don't do X here, it breaks Y" lesson into AGENTS.md so an agent doesn't repeat a mistake. Dedupes against CLAUDE.md/instincts before writing, promotes generalizing lessons out of memory, and keeps AGENTS.md under budget. Use after a bug, regression, or near-miss, or when the user says "capture this" / "make sure we don't do that again".

Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is.

Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.

Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md. Use when joining a new project or setting up Claude Code for the first time in a repo.

Single-task execution loop (plan, execute, verify, hand off). Keeps one agent on one unit of work with a structured context handoff so progress survives across sessions.

Reduce a diff to its essential complexity, removing dead paths, over-engineering, premature abstraction, and incidental churn, without changing behavior.