Claude Skills by a5c-ai

Convert requirements into structured technical specifications with architecture decisions

Break technical specifications into small, implementable stories with dependency ordering

Automated test validation, coverage checking, and quality metrics with aggressive defaults

Fresh adversarial code review with binary PASS/FAIL verdicts, evidence citations, and anchoring bias prevention via fresh reviewer spawning.

Parallel design review by 6 specialist agents (PM, Architect, Designer, Security Design, UX, CTO) with mandatory unanimous approval.

Coordinate external AI tool integration (OpenAI Codex, Google Gemini) for cross-model adversarial review and delegated implementation.

Context priming before work (bd prime) and self-reflection after completion to extract patterns, gotchas, and decisions into the knowledge base.

Execute work units through the rigorous 4-phase Metaswarm cycle (Implement -> Validate -> Adversarial Review -> Commit) with independent quality gate enforcement.

Adversarial plan review by 3 independent reviewers (Feasibility, Completeness, Scope & Alignment) before presenting to user.

Monitor PR lifecycle from creation through merge including CI monitoring, review comment handling, thread resolution, and merge readiness verification.

Decompose implementation plans into discrete work units with enumerated DoD items, file scope declarations, dependency mapping, and human checkpoint flags.

Bug condition/postcondition formalization as testable Behavior Contracts. Defines invariants that must be preserved across fixes.

Convention discovery and rule generation from codebase analysis. Scans project structure, builds search indexes, identifies patterns, and generates enforceable rules.

State capture and restore across context window compactions. Monitors usage thresholds and serializes quality, task, and spec state for seamless continuation.

Observation capture and retrieval across sessions. Stores decisions, discoveries, and bugfix patterns. Searchable via tags and relevance scoring.

Language-specific auto-lint/format/typecheck pipeline. Supports Python (ruff+pyright), TypeScript (prettier+eslint+tsc), Go (gofmt+golangci-lint). Auto-fix and convergence loops.

Specification creation and management for the Pilot Shell methodology. Covers semantic search, clarifying questions, structured spec generation, and iterative refinement.

Strict RED->GREEN->REFACTOR test-driven development with enforcement. Never write production code before a failing test. Atomic commits per TDD cycle.

Verify all phases are complete with weighted quality scoring before allowing session exit.

Log all errors with full context, detect patterns, and suggest approach mutations to avoid repeated failures.

Capture and persist research findings, discoveries, and decision rationale to findings.md.

Create a structured task_plan.md with phases, goals, and checkbox tracking for persistent planning.

Detect and recover previous planning sessions, reconstructing lost context from persistent planning files.

Clarify vague requirements through exploratory questioning and option generation before committing to research or implementation.

Systematic codebase exploration following the Iron Law - understand the problem before exploring code. Four phases with file-finder and web-researcher agents.

Create Architecture Decision Records (ADRs) documenting significant technical choices with context, options, consequences, and sequential numbering.

Final completion discipline including summary generation, plan document updates, and confirmation that all success criteria from the original plan are satisfied.

Disciplined execution of approved plans with step-by-step verification, phase checkpoints, failure investigation, and mandatory code/security reviews.

Transform research findings into actionable implementation plans with stakes-based rigor, test-first strategy, and granular task decomposition.

Security vulnerability assessment identifying OWASP risks, injection vectors, authentication issues, and data exposure with severity classification.

Structured debugging methodology using hypothesis-driven investigation, log analysis, and bisection to isolate and resolve defects.

Verification-before-completion discipline ensuring all success criteria are met, tests pass, and reviews complete before declaring work done.

WASM-based instant code transforms for simple tasks, achieving 352x speedup over LLM inference with zero cost.

Hierarchical coordination and drift detection with frequent checkpoints, shared memory coherence validation, role specialization enforcement, and short task cycles.

Multi-protocol consensus for agent swarms supporting Raft leader election, Byzantine fault tolerance, Gossip state propagation, and CRDT conflict-free merging.

AIDefence security layer with prompt injection blocking, input validation, sandboxed execution, output sanitization, and STRIDE threat modeling.

SONA self-optimizing neural architecture with ReasoningBank trajectory learning, EWC++ anti-forgetting, and reinforcement learning feedback loops.

Complexity-based task routing with Q-Learning optimization, Agent Booster WASM fast-path, and Mixture-of-Experts model selection.

Multi-agent swarm formation and coordinated execution with topology-aware agent deployment, consensus protocols, and anti-drift enforcement.

HNSW vector search for pattern similarity retrieval and knowledge graph maintenance with PageRank scoring, community detection, and 3-tier memory management.

Establish project governing principles including dev guidelines, code quality standards, testing policies, UX requirements, performance benchmarks, and security constraints.

Perform cross-artifact consistency and coverage analysis across constitution, specification, plan, and task artifacts to detect gaps, conflicts, and misalignments before implementation.

Execute development tasks to build features, producing code, tests, and configuration artifacts that satisfy specification requirements and comply with constitution standards.

Design technical architecture, select technology stack, and define implementation strategy from specifications and constitution constraints.

Validate implementation quality through custom checklists, scoring against constitution standards, specification coverage, and producing remediation recommendations.

Write feature specifications as requirements and user stories with acceptance criteria, focusing on business value and testable conditions.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.

Use when you have a written implementation plan to execute in a separate session with review checkpoints between batches.

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work.

Use when receiving code review feedback, before implementing suggestions. Requires technical rigor and verification, not blind implementation.