agwacom-avadbot

avadbot

Skills for Claude Code that turn one AI assistant into a team of specialists. Each slash command activates a different mode — planning, review, shipping, QA, browsing, retrospectives.

Works with any project, any language, any framework.

Skills

Skill	What it does
/avad-plan-ceo-review	Product thinking. Challenges the premise, expands scope, finds the real product.
/avad-plan-eng-review	Engineering plan. Architecture, data flow, edge cases, diagrams, test coverage.
/avad-plan-design-review	Designer's eye plan review. Rates design dimensions 0-10, fixes the plan to get there.
/avad-review	Pre-landing review. Structural bugs, race conditions, trust boundaries, missing tests.
/avad-ship	Ship it. Sync, test, review, push, PR — one command.
/avad-qa	QA testing. Diff-aware, full, quick, or regression mode.
/avad-qa --report-only	Same QA testing, but report-only — never fixes.
/avad-retro	Weekly retro. Commits, patterns, team breakdown, trends.
/avad-debug	Systematic debugger. Root cause investigation, pattern analysis, hypothesis testing.
/avad-document-release	Post-ship docs. Cross-references the diff, updates all project documentation.
/avad-new	Project scaffolding. Asks 5 product questions, generates 16 pre-filled files, detects tech stack, creates GitHub repo.
/avad-help	Skill hub. Shows available skills, recommends the right one, checks for updates.
/avad-design-consultation	Design system creation. Researches your space, proposes aesthetic/typography/color, generates preview, writes DESIGN.md.
/avad-design-review	Visual QA + fix loop. Finds spacing issues, AI slop patterns, interaction problems — then fixes them with before/after screenshots.
/avad-careful	Safety guardrails. Warns before rm -rf, DROP TABLE, force-push, and other destructive commands.
/avad-freeze	Edit boundary. Restricts edits to a specific directory for the session.
/avad-unfreeze	Clears the freeze boundary set by /avad-freeze.
/avad-guard	Full safety mode. Combines /avad-careful + /avad-freeze in one command.
/avad-browse	Headless browser. Navigate, click, screenshot, assert — ~100ms per command.

How it works

Each skill is a cognitive mode. You switch between them as your work progresses:

1. /avad-new
   → Asks 5 questions, scaffolds 16 pre-filled project files

2. /avad-plan-ceo-review
   → "You're thinking too small. The real product is..."

3. /avad-plan-eng-review
   → Architecture diagram, state machine, failure modes, test matrix

4. Build it

5. /avad-review
   → "Race condition on line 47. Trust boundary violation in the enrichment pipeline."

6. Fix the issues

7. /avad-ship
   → Syncs main, runs tests, pushes, opens PR. Done.

8. /avad-qa
   → Reads your diff, finds affected pages, tests each one with a real browser.

Parallel execution

avadbot skills are stateless by design. There is no shared mutable state between sessions — each workspace runs its own browser process with independent cookies, tabs, and logs.

This means you can run as many Claude Code sessions as you want simultaneously using Conductor. Review a PR in one session while QA testing in another and building a feature in a third. The sessions are fully isolated — no port conflicts, no coordination needed.

The skills were built for this. /avad-review analyzes diffs, /avad-qa drives a browser, /avad-ship pushes code — all independently, all in parallel.

Skill details

/avad-plan-ceo-review

Product-level review. Three modes:

• Scope expansion — dream big, find the 10-star version
• Hold scope — keep scope fixed, maximize rigor
• Scope reduction — strip to the essential core

You describe a feature. The skill asks whether you're building the right thing. It pushes past the literal request to find what users actually need.

/avad-plan-eng-review

Engineering-level review. Takes the product direction and makes it buildable:

• Architecture and system boundaries
• Data flow and state transitions
• Failure modes and edge cases
• Diagrams (sequence, state, component)
• Test coverage plan

/avad-review

Pre-landing code review. Not style nits — structural issues:

• N+1 queries, missing indexes
• Race conditions, stale reads
• Trust boundary violations
• Broken invariants, bad retry logic
• Tests that pass while missing the real failure mode

Two modes: local (review current branch) or PR (review a GitHub PR by number).

/avad-ship

One-command shipping. For a branch that's ready to land:

1. Validates branch state
2. Syncs with target branch
3. Runs tests
4. Pre-landing review
5. Pushes
6. Creates PR