tadw

Design a rigorous A/B test with hypothesis, metrics, sample size, duration, guardrails, rollout plan, and decision criteria for a software product

Principles for writing clean, elegant, and maintainable agentic code, drawing from Uncle Bob's Clean Code and Sandi Metz's POODR, transposed into the agentic programming context. Use this skill whenever you are designing or implementing multi-agent systems, tool definitions, orchestration logic, prompt architecture, agent loops, or any code where an LLM drives execution. Trigger this skill when the user asks about agentic code quality, agent design, clean agent architecture, or how to structure tools and prompts well. Also trigger when reviewing or refactoring existing agentic code for clarity.

Record architectural decisions with context, options considered, and rationale for future reference

Comprehensive App Store Optimization audit across 10 weighted factors, producing an ASO Score Card and prioritized action plan for iOS and Android

Author one well-crafted bead and file it. Use whenever someone asks to create a bead, file a bead, write a bead, open an issue, file a ticket, log a bug, capture a TODO, or track a piece of work in bd (beads), even if they do not say the word bead. Interviews for only what cannot be inferred, searches the tracker for a duplicate first, grounds every current-state claim in the code on main, picks the type, drafts the body against the canonical structure (Why, How, Done when, Acceptance Criteria, plus Steps to Reproduce for a bug and Success Criteria for an epic), estimates the diff-size band and splits anything too big, then self-audits the draft with the bead-audit rubric until it passes. Presents the bead and waits for confirmation before writing. Creates it in one call with the native design, notes, and acceptance fields populated, labels it, wires its dependencies, reads it back to prove it landed, and exports the tracker silently.

Refine a bd (beads) backlog by product value: cluster every non-closed bead into themes, pick one theme, and give each bead in it one of seven verdicts (keep, shrink, merge, defer, kill, done, promote). Use whenever someone asks to refine the backlog, prune it, clean it out, or decide whether a bead still deserves to exist, even if they do not say refine by name. It answers 'does this bead deserve to exist?' for a product owner. It is not for 'can this bead be built without mistakes?', which is the bead-audit skill, and not for 'which bead comes first?', which is triage-beads. It computes no score and files no new bead. It grounds each bead by checking only whether the paths and symbols the bead names still exist. It reads docs/milestones.md as a second yardstick and records a route on every bead (on route, detour, or hardening), labeling every hardening bead overbuilt. It applies the verdicts as bd commands in one batch, and only after the author confirms them.

Analyze a project's business model and surface 10 revenue-focused feature ideas with clear 'who pays and why' theses

Simplify and refine code for clarity, consistency, and maintainability while preserving exact functionality. Detects the language and delegates to the appropriate style skill (style-python for Python, style-rails for Ruby/Rails, style-frontend for JS/TS, style-swift for Swift, style-go for Go). Focuses on recently modified code unless instructed otherwise.

Deep competitor teardown with positioning map, moat analysis, feature gaps, trajectory mapping, and strategic implications for a software product

Implement a bead in the house style, invoked as /build. Takes a bead id (preferred) or a feature description, reads the bead from bd rather than re-interviewing you, learns the repo's language, framework, and local conventions before writing anything, loads the matching style skills, implements criterion by criterion with a test per criterion, then simplifies, lints, and writes the counts a hook reads to label the bead `implemented`. Stops at implemented; grading and closing belong to /quality-gates and /verify-acceptance.

Interview the user relentlessly about a plan, design, or decision until every branch of the design tree is resolved. Models the open questions as a tree, asks the whole frontier in one numbered round with a recommended answer per question, then recomputes the frontier from the answers. Finds every fact itself and asks the user only for decisions. Use before writing a plan, filing a bead, or starting a build, whenever the user says grill me, interview me, stress-test this, or ask me questions first, and as the alignment step another skill runs before it commits to a design

Generate 30 improvement ideas, rigorously evaluate each, distill to the very best 5

Fresh-eyes review of a feature plan: acceptance-criteria gate, codebase grounding, 7-dimension evaluation with MECE check, and a verdict

Decompose a feature implementation plan into trackable bd (beads) issues with a dependency graph. Each bead requires Why (Marr L1), How (Marr L2), and Done when (acceptance criteria) before creation. Presents the full list for confirmation, then creates issues and wires dependencies. Keeps the graph shallow and prefers parallel tracks.

Write a product brief (PM-to-engineering handoff) with problem statement, user segments, success metrics, scope, acceptance criteria, and experiment tie-in

Synthesize user signals by segment, size opportunities using JTBD and opportunity scoring, and rank what to build next with evidence quality weighting

Build a prioritized product roadmap with themes, capacity modeling, bet classification, sequencing, dependencies, and clear rationale for what to build when

Build and refresh a product documentation tree under docs/products/, organized by product surface such as web, api, and iOS. The tree holds one document per surface, and one for each capability and feature below it. Grounds every claim in the codebase, and searches that codebase for bugs, feature gaps, and feature debt as a required goal rather than a side effect. Records every finding in a ledger, and turns the ones worth acting on into beads written to the bead-audit standard. Includes a staleness checker, so keeping the tree current is a command you run. Use when asked to map product surfaces, document what the product does by surface, build or refresh docs/products, or audit the product for bugs, gaps, and debt.

Safely operate the production apps (atlas, meridian, compass, ...) running as Docker Compose stacks on a single Hetzner VPS, over SSH. Access is two-hop (SSH in as root, then su - deploy); each app is a Compose stack in the deploy user's home (~/atlas, ~/meridian, ...). Covers service ops (status, logs, restart, up/down) and PostgreSQL data ops (migrations, backups, one-off data fixes) under strong guardrails: read-only by default, secret-free connection, mandatory backup before any data mutation, verify-after, and a written rollback for every risky change. Use when asked to check, restart, deploy-restart, inspect, or change anything on the production VPS.

Cut and publish a release of this plugin: derive the semver bump from the changes since the last tag, write the CHANGELOG version section, bump .claude-plugin/plugin.json, land any feature branch by delegating to the ship skill, commit as chore(release): X.Y.Z, tag vX.Y.Z, and push main and the tag. Fails closed on an undecidable bump, a dirty tree, or the tag hook's validation refusal, and ends with one machine-readable PUBLISH_DONE / PUBLISH_BLOCKED line.

Run the project's QA gates against the change: tests, change coverage, live API probe, lint, type check, doc freshness, hygiene. Scoped to what changed by default. Reads the diff to pick the QA method the change actually needs: real curl requests against a local server for a REST change, a handoff to agent-browser for browser UI, or a test-coverage review for everything else. Takes the gate list from what the project declares, not from guesswork. Report-only, and it never addresses a host other than this machine.

Fix the FAIL criteria and FAIL gates a /tadw:verify-acceptance run recorded in acceptance-report.json, then stop without re-grading the fix. Reads findings only from that report file, never from the diff or a transcript, and refuses to start when the report is missing, stale, foreign, or unreadable. Runs each finding's command, criterion or gate alike, before committing when it names one, edits nothing outside the report's changed_files, refuses a file with uncommitted changes, and ends with one machine line: RECONCILE_ACCEPTANCE_DONE <n> or RECONCILE_ACCEPTANCE_BLOCKED <reason>. Use after a NOT ACCEPTED verdict, never to grade work or to fix a review finding.

Fix the FAIL gate findings a /tadw:quality-gates run recorded in quality-gates-report.json, then stop without re-grading the fix. Reads findings only from that report file, never from the diff or a transcript, and refuses to start when the report is missing, stale, foreign, or unreadable. Runs each finding's gate command before committing, edits nothing outside the report's changed_files, refuses a file with uncommitted changes, and ends with one machine line: RECONCILE_QUALITY_GATES_DONE <n> or RECONCILE_QUALITY_GATES_BLOCKED <reason>. Use after a FAIL verdict, never to grade work or to fix a review finding.

Ingest a new source document into the Research wiki. Reads the source, assesses study quality, discusses key takeaways with the user, then creates source summary and entity/concept pages, cross-references them to existing wiki content, and updates the index and log. Follows the Karpathy LLM Wiki pattern; does not modify the immutable Research/sources/ files.

Review recently changed code as if seeing it for the first time. Auto-detects changed files from git, reads full files for context, finds genuine bugs and logic errors, and fixes them directly. Conservative scope: real bugs, not style preferences.

Reviews Python code against PEP 8 and the Google Python Style Guide. Covers style, imports, naming, docstrings, type hints, code quality, security, performance, and maintainability. Use when reviewing, auditing, or checking the quality of Python code.

Use when reviewing Rails 8 code before merge or PR - systematic review process covering security (XSS, SQL injection, authorization), Rails/Hotwire conventions, performance, and DRY with verify-before-flag discipline and priority-ranked findings

This skill should be used when the user asks to "build a roadmap dashboard", "generate a project dashboard", "create docs/roadmap.html", "visualize project status and remaining beads work", or wants a self-contained interactive HTML dashboard that synthesizes the codebase and the beads tracker into architecture diagrams, a completion gauge, a Kanban board, and a prioritized roadmap. Not for markdown status reports or product docs.

Land a reviewed bead's feature branch on main locally: rebase onto the base, run the repository's own check suite as the gate, squash-merge, close the bead, push main, delete the branch, and name which bead to pick up next. No PR and no GitHub CI; the local gate is the only thing that decides. Runs unattended, fails closed on a red or undetected gate, never force-pushes main, never hand-edits the tracker JSONL, and ends with one machine-readable SHIP_DONE / SHIP_BLOCKED line.

Use when writing controllers, models, concerns, or POROs in the Fizzy codebase - enforces Fizzy's vanilla Rails house style and conventions

Writes and reviews JavaScript/TypeScript, React, and Vue in the house style - TRUE components, frontend-specific deltas (small presentational components, logic in hooks/composables, typed props, no class components) layered on the injected universal style core.

Writes and reviews Go in the house style - Go-specific deltas on top of the injected universal TRUE-code core, emphasizing accept interfaces and return structs, wrapped errors over sentinels, zero-value-useful types, table-driven tests, and a package API that reads from its doc comment

Writes and reviews Markdown when the document itself is the deliverable. Use when composing, revising, or reviewing a README, a runbook, a wiki or `docs/` page, an ADR under `docs/adr/`, a plan, kept notes, or any prompt asset (`SKILL.md`, `agents/*.md`, `commands/*.md`, `AGENTS.md`), even when the request never says Markdown or style. Load before writing the first line.

Writes and reviews Python in the house style. Use when writing, editing, or reviewing any `.py` file, including a design or object-oriented-design review of Python.

Use when generating Rails code, evaluating gems, or making Rails architectural decisions - enforces the Rails 8 Way (convention over configuration, Solid Stack over external dependencies, Hotwire)

Use when writing or reviewing RSpec tests in a Rails app - the RSpec/Rails delta on the style-testing core, covering request specs over controller specs, let/let!/subject mechanics, FactoryBot build vs create, and shared-example scoping

Writes and reviews Swift/iOS in the house style (protocol-oriented, value-type-first, TRUE code). Use when writing or reviewing Swift code.

Use when writing, reviewing, or restructuring tests in any language or framework (pytest, Vitest, Jest, XCTest, Swift Testing, Minitest, JUnit, Go testing) - one behavior per test, hoisted declarative setup, deterministic clocks and identification, scenario-named groups, and what not to test

Best practices for writing and reviewing Terraform / Infrastructure as Code across AWS, Azure, and GCP

Rank the open beads in a bd (beads) tracker by ROI, value delivered per unit of effort, and answer one question: which single bead to pick up next. Use this whenever someone asks what to work on next, what to pick up, what has the highest ROI, what is on their plate, or wants the backlog prioritized, even if they do not say beads or triage by name. Reads the tracker through the bd and bv command-line tools only, never an MCP server. Takes readiness from bd ready and bd blocked, the measured graph facts (unblock counts, PageRank) from bv --robot-triage, then scores every candidate on an explicit value-over-effort rubric in which every point cites evidence from a stored field or the bead body. Output: one top pick with the scoring arithmetic shown and its claim command, a scored leaderboard so the ranking can be audited, and the blocked list. Deterministic: the same tracker state always yields the same pick. Report-only: it never claims, closes, or edits a bead.

Conduct a comprehensive UX review of a running web app via Playwright. Captures screenshots, exercises forms and error states, performs keyboard accessibility and three-viewport responsive evaluation, then produces a severity-ranked report covering accessibility, design system, IA, interaction, content, emotional design, and cognitive load.

Conduct a comprehensive UX review of an iOS app running in the Simulator. Captures screenshots via xcrun simctl, tests Dynamic Type and Dark Mode and Bold Text configurations, and produces a severity-ranked report covering all seven design dimensions against Apple HIG standards.

Check a finished unit of work against its bead's acceptance criteria and the QA gates. Resolves the bead from bd, resolves the changed set once (with `--base <ref>` on a stacked branch), grades each criterion against evidence rather than against the diff, runs the QA gates, and reports one verdict table. It edits no file in the working tree and closes no bead. It writes exactly two files, both in `<git-dir>`: `acceptance-changed.txt`, the changed set its gates checked, and `acceptance-report.json`, the version 2 report of every criterion and gate, written through `write_acceptance_report.py`. A Stop hook reads the report and applies the `accepted` label, so this skill runs no bd command of its own.