bee

Skills (21)

• Skill ai-ergonomics

  This skill should be used when evaluating how well code supports LLM-assisted development. Contains context window friendliness, explicitness, module boundaries, test-as-spec, and naming criteria.

  Any agent

  npx skills add incubyte/ai-plugins --skill ai-ergonomics

• Skill ai-workflow

  This skill should be used when explaining why Bee follows spec-first TDD workflows, or when teaching mode is on. Contains the reasoning behind spec → plan → test → code ordering.

  Any agent

  npx skills add incubyte/ai-plugins --skill ai-workflow

• Skill architecture-patterns

  This skill should be used when evaluating architecture options, checking dependency direction, or deciding between onion, MVC, and simple patterns. Contains YAGNI-based decision criteria.

  Any agent

  npx skills add incubyte/ai-plugins --skill architecture-patterns

• Skill bee-state

  This skill should be used when updating workflow state in bee-state.local.md. Contains the full command reference for update-bee-state.sh including init, set, get, clear, all flags, and multi-line…

  Any agent

  npx skills add incubyte/ai-plugins --skill bee-state

• Skill boundary-generation

  This skill should be used after discovery completes on a greenfield project when the discovery document contains a Module Structure section.

  Any agent

  npx skills add incubyte/ai-plugins --skill boundary-generation

• Skill brainstorming

  This skill should be used when the user wants to brainstorm, explore ideas, think through options, says 'let's brainstorm', 'what are our options', 'how might we', 'what if we', 'help me think…

  Any agent

  npx skills add incubyte/ai-plugins --skill brainstorming

• Skill browser-testing

  This skill should be used when running browser-based verification. Supports two providers: Claude-in-Chrome (primary) and chrome-devtools-mcp (fallback).

  Any agent

  npx skills add incubyte/ai-plugins --skill browser-testing

• Skill clean-code

  This skill should be used when writing, reviewing, or refactoring code. Contains SRP, DRY, YAGNI, naming, error handling, dependency direction, and Kent Beck's four rules of simple design.

  Any agent

  npx skills add incubyte/ai-plugins --skill clean-code

• Skill code-review

  This skill should be used when performing code reviews, analyzing git hotspots, or detecting coupling. Contains Adam Tornhill's code-as-crime-scene methodology and effort sizing.

  Any agent

  npx skills add incubyte/ai-plugins --skill code-review

• Skill collaboration-loop

  This skill should be used when processing @bee annotations in documents or managing [ ] Reviewed gates. Contains the exact comment card format and review loop rules.

  Any agent

  npx skills add incubyte/ai-plugins --skill collaboration-loop

• Skill debugging

  This skill should be used when diagnosing failures, fixing bugs, or investigating why tests don't pass. Contains systematic debugging: reproduce first, read before you change, assume nothing, find…

  Any agent

  npx skills add incubyte/ai-plugins --skill debugging

• Skill design-fundamentals

  This skill should be used when making UI/UX decisions, designing layouts, choosing colors and typography, writing UI specs, or reviewing visual components.

  Any agent

  npx skills add incubyte/ai-plugins --skill design-fundamentals

• Skill grill-me

  Interview the user relentlessly about a plan, design, or idea until reaching shared understanding. Use when the user wants to stress-test their thinking, asks to be grilled, says 'poke holes in…

  Any agent

  npx skills add incubyte/ai-plugins --skill grill-me

• Skill grill-me-with-context

  Interview the user about a plan or design with full codebase context. Use when the user wants to stress-test their thinking against the actual codebase, says 'grill me with context', 'challenge this…

  Any agent

  npx skills add incubyte/ai-plugins --skill grill-me-with-context

• Skill lsp-analysis

  This skill should be used when performing precise dependency analysis with LSP tools. Contains availability checking, graph reasoning, and graceful degradation.

  Any agent

  npx skills add incubyte/ai-plugins --skill lsp-analysis

• Skill model-tiers

  This skill should be used when an orchestrator needs to choose or resolve a model for a delegated agent — i.e. by /bee:planner when authoring a plan (assigning a capability tier per agent per slice)…

  Any agent

  npx skills add incubyte/ai-plugins --skill model-tiers

• Skill requirement-architect

  Rewrites software requirements to lead to better code design and architecture. Use this skill whenever a user shares requirements, user stories, feature specs, acceptance criteria, or PRDs and wants…

  Any agent

  npx skills add incubyte/ai-plugins --skill requirement-architect

• Skill resolve-m-conflicts

  This skill should be used when resolving git merge conflicts. Parses conflict markers, shows clean side-by-side diffs, explains why each conflict occurred using git history, and presents resolution…

  Any agent

  npx skills add incubyte/ai-plugins --skill resolve-m-conflicts

• Skill spec-writing

  This skill should be used when writing specs, acceptance criteria, or slicing features into vertical slices. Contains adaptive depth by risk and out-of-scope capture.

  Any agent

  npx skills add incubyte/ai-plugins --skill spec-writing

• Skill tdd-practices

  This skill should be used when writing a TDD plan, reviewing test quality, choosing between unit and integration tests, or applying red-green-refactor.

  Any agent

  npx skills add incubyte/ai-plugins --skill tdd-practices

• Skill try-it-yourself

  This skill should be used after all slices are verified and before review. Contains templates for generating contextual 'Try it yourself' manual verification steps based on what was built (frontend…

  Any agent

  npx skills add incubyte/ai-plugins --skill try-it-yourself

Agents (36)

• Agent architecture-advisor

  Use this agent to evaluate architecture options when the task warrants a decision. Most tasks just follow existing patterns. Includes YAGNI check.

• Agent architecture-impl-advisor

  Use this agent to evaluate architecture for spec-driven development (SDD). Reads the spec and codebase, evaluates across 6 dimensions (Simplicity, Cohesion, Decoupling, Evolvability, Testability…

• Agent architecture-test-writer

  Use this agent to generate runnable ArchUnit-style boundary tests from a confirmed architecture assessment report. Produces passing tests for healthy boundaries and intentionally failing tests for…

• Agent browser-verifier

  Use this agent to verify a running app in the browser — checks acceptance criteria, console errors, runtime exceptions, and visual state via browser MCP tools.

• Agent context-gatherer

  Use this agent to read a codebase and understand patterns, conventions, and the area being changed. Run before planning. Use for any task beyond TRIVIAL.

• Agent design-agent

  Use this agent to produce a design brief for UI-involved projects. For existing design systems, it reads and documents what exists.

• Agent discovery

  Use this agent as a PM persona that interviews users and produces a client-shareable PRD. Works standalone via /bee:discover or internally via /bee:sdd.

• Agent domain-language-extractor

  Use this agent to extract domain vocabulary from README, docs, the company's website, and code naming patterns. Compares domain language against code structure to find vocabulary drift and boundary…

• Agent onboard

  Use this agent to analyze a codebase and deliver an interactive onboarding walkthrough adapted to the developer's role, experience, and focus area. Use when a developer is joining an existing project.

• Agent programmer

  Use this agent to write code for a TDD plan slice — writes failing tests, makes them pass, refactors. Follows strict RED-GREEN-REFACTOR one test at a time. Use after TDD plan is reviewed and approved.

• Agent qc-planner

  Use this agent to synthesize review agent outputs into a prioritized test plan. Scores hotspots, inventories existing tests, assesses testability, and produces a fixed-format plan.

• Agent quick-fix

  Use this agent when the orchestrator classifies a task as TRIVIAL — typos, config changes, obvious one-liners. Makes the fix and runs tests.

• Agent recap

  Use this agent after SDD completes to walk the developer through what was built — files changed, core logic, tests written, architecture decisions.

• Agent review-ai-ergonomics

  Use this agent to review code for how well LLMs can work with it — context window friendliness, explicitness, module boundaries, test-as-spec, naming, and documentation quality.

• Agent review-behavioral

  Use this agent to analyze git history to find hotspots (high-churn + high-complexity files) and temporal coupling (files that change together). Use as part of the multi-agent review.

• Agent review-code-quality

  Use this agent to review code against clean code principles — SRP, DRY, YAGNI, naming, small functions, error handling, dependency direction. Use as part of the multi-agent review.

• Agent review-coupling

  Use this agent to analyze structural coupling — import dependencies, afferent/efferent coupling, change amplifiers, and decoupling opportunities. Use as part of the multi-agent review.

• Agent review-org-standards

  Use this agent to review code against the target project's CLAUDE.md conventions and rules. Checks project-specific patterns, naming, architecture, and any custom standards.

• Agent review-team-practices

  Use this agent to review team practices — commit message quality and PR review substance. Identifies rubber-stamp reviews and low-quality commit messages. Use as part of the multi-agent review.

• Agent review-tests

  Use this agent to review test quality — vanity test detection, assertion quality, mocking discipline, behavior-based testing, isolation, naming, frontend-specific checks, and coverage gaps.

• Agent reviewer

  Use this agent to review the complete body of work after all slices are done. Risk-aware ship recommendation. Use after all slices are verified complete.

• Agent sdd-verifier

  Use this agent to verify a completed SDD slice — tests pass, test quality assessed, criteria met, patterns followed. Risk-aware.

• Agent slice-builder

  Merged build agent for ONE plan slice in the /bee:start → /bee:planner → /bee:plan-implementer workflow. Writes the slice's plan-specified tests, confirms they fail (red), writes the code to make…

• Agent slice-coder

  Use this agent to write production code for one spec slice in the SDD workflow. Receives the spec, architecture recommendation, and context — writes all production code for the slice's acceptance…

• Agent slice-tester

  Use this agent to write tests for completed production code in the SDD workflow. Reads production code with adversarial eyes, assesses testability, makes small testability refactors if needed…

• Agent spec-builder

  Use this agent to interview the developer and build a spec. Depth adapts to task size and risk. Use for FEATURE and EPIC workflows after context gathering.

• Agent tdd-coder

  Use this agent as the "code" side of ping-pong TDD. It receives a failing test and writes the minimum production code to make it pass. Refactors after GREEN.

• Agent tdd-ping-pong

  Use this agent to run ping-pong TDD on a spec. It orchestrates a test-writer and coder agent in alternating RED-GREEN-REFACTOR cycles, one test at a time, until all acceptance criteria are…

• Agent tdd-planner-cqrs

  Use this agent to generate a split TDD plan for CQRS architectures. Command side (behavior + events) and query side (projections + read models). One plan per slice.

• Agent tdd-planner-event-driven

  Use this agent to generate a contract-first TDD plan for event-driven architectures. One plan per slice. Use when architecture decision is event-driven or message-based.

• Agent tdd-planner-mvc

  Use this agent to generate a TDD plan for MVC architecture. One plan per slice. Use when architecture decision is MVC. <example> Context: Architecture-advisor confirmed the codebase uses MVC user…

• Agent tdd-planner-onion

  Use this agent to generate an outside-in TDD plan for onion/hexagonal architecture. One plan per slice. Use when architecture decision is onion or hexagonal.

• Agent tdd-planner-simple

  Use this agent to generate a simple test-first plan. For small features and utilities. Use when architecture decision is simple or default.

• Agent tdd-test-writer

  Use this agent as the "test" side of ping-pong TDD. It writes exactly ONE failing test, runs it to confirm RED, and returns the test name and error. Never writes more than one test per invocation.

• Agent tidy

  Use this agent to clean up the area before building. Creates a separate commit. Optional — skipped if area is clean. Use when context gatherer flags tidy opportunities.

• Agent verifier

  Use this agent to verify a completed slice — tests pass, criteria met, patterns followed. Risk-aware. Use after execution of each slice.

Commands (16)

• Command architect

  Architectural health assessment grounded in domain language. Compares how a product describes itself against how the code is structured.

• Command brainstorm

  Start a brainstorming session. Open-ended, collaborative idea generation for product, architecture, UX, or any problem space.

• Command browser-test

  Run browser-based regression tests against specs. Verifies acceptance criteria in a running app via Chrome MCP, produces pass/fail reports with screenshots. Read-only — does not modify code.

• Command coach

  Analyze your development sessions and get actionable coaching insights

• Command discover

  Start a discovery session. A PM persona that interviews you (or synthesizes from transcripts) and produces a client-shareable PRD. Use standalone or let /bee invoke it automatically.

• Command help

  Explain Bee's features interactively — what each command does, when to use it, what artifacts it produces. Adapts to your project context.

• Command migrate

  Analyze a legacy and new codebase to produce a prioritized, independently-shippable migration plan.

• Command onboard

  Interactive developer onboarding for existing projects. Analyzes the codebase and delivers an adaptive walkthrough with knowledge checks.

• Command ping-pong

  Run ping-pong TDD on a spec. Two agents alternate — one writes a failing test, the other makes it pass — until all acceptance criteria are implemented.

• Command plan-implementer

  Canonical plan executor. Implements an execution plan one merged build agent per slice (tests + code together, at each slice's plan-assigned model tier), then reviews and verifies once at the end.

• Command planner

  Authors the execution plan — the prescriptive "how" that lets a lower-tier model write good code. Runs on the best model, once per feature.

• Command qc

  Quality coverage analysis with hotspot-driven test planning. Finds high-risk untested code and produces a prioritized test plan.

• Command review

  Standalone code review with hotspot analysis, tech debt prioritization, and developer coaching.

• Command sdd

  Use spec to drive development. Works with or without a pre-built spec. With a spec path, skips to context → architecture → slice loop.

• Command spec-writer

  Spec authoring link of Bee's plan-driven chain. Produces a testable, slice-decomposed spec from a discovery doc, a focused conversation, or a task description — via bee's spec-builder agent, which…

• Command start

  Triage router and the first command to run when the user doesn't know which Bee command applies. Takes a description, classifies the work (bug / small feature / large feature / exploratory /…

From Anthropic's public plugin directory, read on 2026-10-15. Find a skill by task.