specification-generation
Convert requirements into structured technical specifications with architecture decisions
story-decomposition
Break technical specifications into small, implementable stories with dependency ordering
test-enforcement
Automated test validation, coverage checking, and quality metrics with aggressive defaults
adversarial-review
Fresh adversarial code review with binary PASS/FAIL verdicts, evidence citations, and anchoring bias prevention via fresh reviewer spawning.
design-review-gate
Parallel design review by 6 specialist agents (PM, Architect, Designer, Security Design, UX, CTO) with mandatory unanimous approval.
external-tool-coordination
Coordinate external AI tool integration (OpenAI Codex, Google Gemini) for cross-model adversarial review and delegated implementation.
knowledge-curation
Context priming before work (bd prime) and self-reflection after completion to extract patterns, gotchas, and decisions into the knowledge base.
orchestrated-execution
Execute work units through the rigorous 4-phase Metaswarm cycle (Implement -> Validate -> Adversarial Review -> Commit) with independent quality gate enforcement.
plan-review-gate
Adversarial plan review by 3 independent reviewers (Feasibility, Completeness, Scope & Alignment) before presenting to user.
pr-shepherding
Monitor PR lifecycle from creation through merge including CI monitoring, review comment handling, thread resolution, and merge readiness verification.
work-unit-decomposition
Decompose implementation plans into discrete work units with enumerated DoD items, file scope declarations, dependency mapping, and human checkpoint flags.
brainstorming
Clarify vague requirements through exploratory questioning and option generation before committing to research or implementation.
code-review
Structured code quality assessment with Conventional Comments format, scaled review depth, and soft-gating verdicts preserving user autonomy.
codebase-research
Systematic codebase exploration following the Iron Law - understand the problem before exploring code. Four phases with file-finder and web-researcher agents.
decision-documentation
Create Architecture Decision Records (ADRs) documenting significant technical choices with context, options, consequences, and sequential numbering.
finishing-work
Final completion discipline including summary generation, plan document updates, and confirmation that all success criteria from the original plan are satisfied.
plan-implementation
Disciplined execution of approved plans with step-by-step verification, phase checkpoints, failure investigation, and mandatory code/security reviews.
plan-writing
Transform research findings into actionable implementation plans with stakes-based rigor, test-first strategy, and granular task decomposition.
security-review
Security vulnerability assessment identifying OWASP risks, injection vectors, authentication issues, and data exposure with severity classification.
systematic-debugging
Structured debugging methodology using hypothesis-driven investigation, log analysis, and bisection to isolate and resolve defects.
verification
Verification-before-completion discipline ensuring all success criteria are met, tests pass, and reviews complete before declaring work done.
anti-drift
Hierarchical coordination and drift detection with frequent checkpoints, shared memory coherence validation, role specialization enforcement, and short task cycles.
consensus-mechanisms
Multi-protocol consensus for agent swarms supporting Raft leader election, Byzantine fault tolerance, Gossip state propagation, and CRDT conflict-free merging.
security-hardening
AIDefence security layer with prompt injection blocking, input validation, sandboxed execution, output sanitization, and STRIDE threat modeling.
self-optimization
SONA self-optimizing neural architecture with ReasoningBank trajectory learning, EWC++ anti-forgetting, and reinforcement learning feedback loops.
smart-routing
Complexity-based task routing with Q-Learning optimization, Agent Booster WASM fast-path, and Mixture-of-Experts model selection.
swarm-orchestration
Multi-agent swarm formation and coordinated execution with topology-aware agent deployment, consensus protocols, and anti-drift enforcement.
vector-memory
HNSW vector search for pattern similarity retrieval and knowledge graph maintenance with PageRank scoring, community detection, and 3-tier memory management.
constitution-creation
Establish project governing principles including dev guidelines, code quality standards, testing policies, UX requirements, performance benchmarks, and security constraints.
cross-artifact-analysis
Perform cross-artifact consistency and coverage analysis across constitution, specification, plan, and task artifacts to detect gaps, conflicts, and misalignments before implementation.
implementation-execution
Execute development tasks to build features, producing code, tests, and configuration artifacts that satisfy specification requirements and comply with constitution standards.
planning-design
Design technical architecture, select technology stack, and define implementation strategy from specifications and constitution constraints.
quality-checklist
Validate implementation quality through custom checklists, scoring against constitution standards, specification coverage, and producing remediation recommendations.
specification-writing
Write feature specifications as requirements and user stories with acceptance criteria, focusing on business value and testable conditions.
task-decomposition
Convert technical plans into actionable development tasks with dependency graphs, effort estimates, and parallelization opportunities.
dispatching-parallel-agents
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.
executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints between batches.
finishing-a-development-branch
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work.
receiving-code-review
Use when receiving code review feedback, before implementing suggestions. Requires technical rigor and verification, not blind implementation.
requesting-code-review
Use when completing tasks, implementing major features, or before merging to verify work meets requirements.
subagent-driven-development
Use when executing implementation plans with independent tasks in the current session. Dispatches fresh subagent per task.
using-git-worktrees
Use when starting feature work that needs isolation from current workspace or before executing implementation plans.
using-superpowers
Use when starting any conversation. Establishes how to find and use skills, requiring skill invocation before any response.
writing-plans
Use when you have a spec or requirements for a multi-step task, before touching code. Creates bite-sized TDD implementation plans with dependency tracking.
writing-skills
Use when creating new skills, editing existing skills, or verifying skills work before deployment.
autonomous-coding-engagement
Autonomously engage with complex coding tasks — multi-step planning, tool use, self-correction, and solution verification without human intervention.
autonomous-research-engineering
Autonomous research engineering — web search orchestration, source synthesis, hypothesis formation, and structured research report generation.
closed-book-frontier-reasoning
Perform closed-book frontier reasoning — complex problem solving from internalized knowledge without external retrieval or tool use.
general-knowledge-reasoning
Apply general knowledge reasoning across diverse domains — trivia, commonsense inference, analogy, and factual question answering.
guardrails-ai-setup
Guardrails AI validation framework setup for LLM applications. Implement input/output validation, safety checks, and structured output enforcement.
Page 2 of 4 · 189 results