/ce:brainstorm
Collaborative Requirements Exploration
Use when: a feature request is vague, ambitious, or has multiple valid approaches. Also when you're unsure about scope or want to think through trade-offs before committing.
Opens a structured dialogue — Claude asks clarifying questions, surfaces edge cases, challenges assumptions, and maps the problem space with you. Ends by writing a right-sized requirements doc that captures what you actually want to build (not just what you said).
Requirements doc written to disk
Scope boundaries clarified
Alternative approaches surfaced
"let's brainstorm"
"think through X"
"help me frame this"
/ce:ideate
Proactive Improvement Ideas
Use when: you want Claude to suggest what to build next — rather than bringing your own idea. Good for project stagnation, pre-sprint ideation, or getting a second opinion on direction.
Claude reads the current codebase, assesses where it's weak or where users are likely struggling, and generates a shortlist of grounded improvement ideas — each critically evaluated before being presented. Ends with a recommended direction you can run with.
Ranked list of improvement ideas
Rationale and trade-offs for each
Recommended next step
"what should I improve"
"give me ideas"
"surprise me"
/ce:plan
Feature Planning Engine
Use when: you have a clear feature description (or a requirements doc from /ce:brainstorm) and want a structured, checked plan.md ready for /ce:work.
Spins up parallel research agents: one reads your codebase, one checks past plans for relevant decisions, one optionally pulls framework docs. Synthesises into a structured plan: problem statement, approach, files to touch, and acceptance criteria with checkboxes.
The plan is saved to plans/features/ — it survives context loss and acts as a checkpoint between sessions.
plans/features/your-feature.md written
Acceptance criteria with checkboxes
Files to touch, risks flagged
"plan this feature"
"write a plan for"
"create a plan.md"
/ce:deepen-plan
Plan Depth Enhancer
Use when: you have a plan but it feels shallow — missing best practices, edge cases, or implementation detail. Run after /ce:plan for anything non-trivial.
Takes an existing plan and launches parallel research agents — one per section. Each agent adds depth: pulls official docs for any libraries involved, adds community-known gotchas, annotates the acceptance criteria with how to verify them. Returns an enriched plan.
Each plan section annotated with research
Library-specific gotchas surfaced
Verification steps added to criteria
"deepen this plan"
"add more detail"
"research this plan"
/ce:document-review
Requirements Doc Refiner
Use when: a requirements or plan document exists and you want a structured review before handing it off — or before running /ce:work on it.
Reviews a document for completeness, ambiguity, missing edge cases, and internal contradictions. Provides specific, actionable feedback. Think of it as a code review, but for your spec. Prevents the most common source of implementation drift.
Annotated review with specific feedback
Gaps and ambiguities flagged
Updated doc ready for implementation
"review this spec"
"check this plan"
"is this complete"
/ce:work
Plan Execution Engine
Use when: you have a plan.md and want Claude to implement it — not just talk about it. The primary skill for getting code written.
Takes a plan and executes it end-to-end: breaks into tasks, implements each one, runs tests, checks off acceptance criteria. Context lost mid-way? Point a new session at the same plan and continue — the checkboxes are the memory.
Designed to run autonomously with bypass permissions on. You can be working in a different window.
Code written and tests passing
Plan checkboxes ticked as work completes
Summary of what was done (and what wasn't)
"execute this plan"
"implement this"
"build it"
/ce:resolve-todo-parallel
Parallel TODO Resolver
Use when: you have a backlog of TODO comments or CLI tasks and want to clear them in bulk — especially when they're independent of each other.
Finds all pending todos, groups them by independence, and launches parallel sub-agents to resolve them simultaneously. After each batch, saves learnings to prevent re-introducing the same issues. Cleans up completed todos on finish.
All resolvable TODOs addressed
Learnings compounded to memory
Completed items removed from queue
"clear my todos"
"resolve all pending tasks"
"work through the queue"
/ce:reproduce-bug
Bug Reproduction & Investigation
Use when: you receive a bug report (GitHub issue, user report) and need to confirm whether it's real, reproduce the exact conditions, and understand the root cause before fixing.
Takes a GitHub issue number or description, systematically reproduces the reported behaviour, and validates whether it's an actual bug vs expected behaviour. Captures the exact reproduction steps, the stack trace, and the likely root cause — so the fix is targeted, not guesswork.
Confirmed reproduction steps
Root cause identified
Ready for /ce:plan to fix
"reproduce this bug"
"investigate issue #123"
"is this actually a bug"
/ce:review
Exhaustive Multi-Agent Code Review
Use when: code is ready for review — before opening a PR, after a large feature, or when you want a genuinely adversarial pass, not a rubber stamp.
Launches multiple specialist review agents in parallel: architecture, security, performance, data integrity, test coverage, and simplicity. Each agent works independently in a git worktree so they don't interfere. Results are synthesised into a prioritised, actionable report.
This is the most thorough review mode. Use it sparingly — on non-trivial PRs.
Multi-perspective review report
Issues prioritised by severity
Go / no-go recommendation
"review this PR"
"adversarial review"
"thorough code review"
/ce:test-browser
Browser Test Runner
Use when: you've made UI changes and want to run browser tests against the affected pages before merging.
Identifies which pages are affected by the current branch or PR, then runs automated browser tests against them. Catches visual regressions and interaction failures that unit tests miss. Works against localhost or a preview deployment.
Test results per affected page
Screenshots of failures
Pass / fail summary
"test the UI"
"run browser tests"
"check affected pages"
/ce:feature-video
Feature Walkthrough Video
Use when: a PR needs a visual demo for reviewers, or you want to show what changed without writing a long description.
Records a screen video walkthrough of the feature — navigating the UI, demonstrating the key flows, showing before/after if relevant. Uploads the video and adds it to the PR description automatically. Reviewers see the feature in action without checking out the branch.
Video recorded and uploaded
PR description updated with embed
"record a demo"
"add video to PR"
"walkthrough this feature"
/ce:agent-browser
Browser Automation CLI
Use when: any task requires interacting with a website — navigating, form-filling, scraping, testing, logging in, or clicking.
Gives Claude a full browser it can control programmatically. Navigate to pages, fill forms, click buttons, extract data, take screenshots. Works for manual QA, automated testing, web scraping, or any task that requires a real browser rather than an API.
"open this page"
"fill out this form"
"scrape this site"
"take a screenshot"
/ce:git-worktree
Isolated Parallel Development
Use when: you want to work on two branches simultaneously without stashing/switching, or run parallel agents in isolation.
Creates, lists, switches, and cleans up git worktrees with a simple interactive interface. Each worktree is an independent copy of the repo at a given branch — multiple Claude sessions can work on different features at the same time without stepping on each other.
"create a worktree"
"parallel branch"
"isolate this work"
/ce:rclone
Cloud File Sync & Upload
Use when: you need to upload files — images, videos, documents — to S3, Cloudflare R2, Backblaze B2, Google Drive, or any S3-compatible storage.
Wraps rclone for easy file transfer to cloud storage. Upload a single file or sync an entire directory. Returns the public URL. Useful after /ce:feature-video for getting videos to a CDN, or for backing up build artefacts.
"upload to S3"
"sync to cloud"
"upload this video"
/ce:claude-permissions-optimizer
Permission Fatigue Fixer
Use when: you're clicking "approve" too often, or you've just set up a new project and want to get permissions dialled in from the start.
Analyses your recent session history, identifies Bash commands that are safe to auto-approve, and adds them to your settings.json allowlist. Eliminates repetitive permission prompts without exposing you to genuinely risky operations. Run once per project.
"too many prompts"
"permission fatigue"
"optimize permissions"
/ce:proof
Shared Document Creation
Use when: you need to create a shareable markdown document — specs, proposals, summaries — and share a link rather than a file.
Creates and publishes markdown documents via the Proof web API. Supports commenting, edit suggestions, and sharing. Useful for async spec reviews with stakeholders who don't use GitHub, or for externalising plans for feedback.
"share this doc"
"create a proof doc"
"publish this spec"
/ce:frontend-design
High-Quality UI Building
Use when: building or modifying any UI — landing pages, dashboards, components. The standard for design quality is high: not AI slop.
Builds web interfaces with genuine design quality — proper typography, colour, spacing, motion, and composition. Detects your existing design system and respects it. Takes screenshots to verify results before declaring done. Covers greenfield builds and modifications to existing apps.
"build this UI"
"design this page"
"make this look good"
/ce:dhh-rails-style
DHH / 37signals Rails Style
Use when: writing Rails code and you want strict adherence to the DHH aesthetic — fat models, thin controllers, REST purity, Hotwire patterns, no JS framework contamination.
Embodies the 37signals philosophy: clarity over cleverness, the Rails way over abstraction, Hotwire over React, Current attributes, no unnecessary gems. Includes an internal reviewer that will call out anti-patterns before they ship.
"DHH style"
"37signals way"
"Rails conventions"
/ce:andrew-kane-gem-writer
Ruby Gem Author (Andrew Kane Style)
Use when: creating or refactoring a Ruby gem. Andrew Kane's gems (Searchkick, Ahoy, Blazer) are the benchmark for clean, minimal, production-ready Ruby library code.
Applies Andrew Kane's patterns: minimal dependencies, clean public API, sensible defaults that rarely need overriding, excellent README, battle-tested conventions. Produces gems that feel like they belong in the Ruby ecosystem.
"create a gem"
"write a Ruby library"
"Andrew Kane style"
/ce:dspy-ruby
LLM Apps with DSPy.rb
Use when: building AI features in Ruby — LLM signatures, modules, agents with tools, prompt optimisation. DSPy.rb gives you type-safe, testable LLM interactions.
Builds LLM-powered features using DSPy.rb: defines typed signatures, composes modules, configures model providers, builds agent tool loops, and writes optimisable prompts. Covers the full DSPy lifecycle from prototype to production.
"DSPy"
"LLM feature in Ruby"
"AI module"
/ce:agent-native-architecture
Agent-First System Design
Use when: designing a system where agents are first-class — anything an agent can do, a user can do, and vice versa. Also when building MCP tools or self-modifying systems.
Applies agent-native design principles: every UI action exposed as an agent tool, MCP server design, agent loop architecture, self-modifying capability. Ensures parity between what humans can do in the UI and what agents can do programmatically.
"agent-native"
"MCP tool"
"autonomous agent system"
/ce:gemini-imagegen
Image Generation & Editing
Use when: you need to generate or edit images — logos with text, product mockups, stickers, style transfers, or any image creation/manipulation task.
Uses the Gemini API for text-to-image generation, image editing, multi-turn refinement, and composition from multiple reference images. Supports iterative refinement — describe what's wrong, and Gemini edits the existing output rather than starting over.
"generate an image"
"edit this image"
"create a logo"
/ce:every-style-editor
Every Magazine Style Editor
Use when: reviewing or editing copy that needs to meet Every's style guide — grammar, punctuation, mechanics, and editorial voice.
Performs a systematic line-by-line review: grammar, punctuation, mechanics, and Every-specific style compliance. Returns specific edits with rationale, not just "make it better." Use before publishing any copy that carries the Every brand.
"Every style"
"edit this copy"
"style review"