Claude Skills by tstapler

Run ideation interview and create requirements.md to start a new Manifest-Driven Development project

Analyze TODO.md, curate documentation, and recommend the optimal next step using Implementation Plan format

Review current plan status and recommend next action

Analyze existing project plans, update them to reflect current project state, archive completed plans, and commit changes

Complete browser automation with Playwright. Auto-detects dev servers,

Use this agent when you need to create automated browser tests using

Use this agent when you need to debug and fix failing Playwright tests

Use this agent when you need to create comprehensive test plan for a

When the user wants to apply, document, or enforce brand guidelines for any product or company. Also use when the user mentions 'brand guidelines,' 'brand colors,' 'typography,' 'logo usage,' 'brand voice,' 'visual identity,' 'tone of voice,' 'brand standards,' 'style guide,' 'brand consistency,' or 'company design standards.' Covers color systems, typography, logo rules, imagery guidelines, and tone matrix for any brand — including Anthropic's official identity.

Establish or iterate on the brand strategy and marketing direction for a project. Use when starting a new project, setting up brand context for the first time, or when the user says 'help me brand this', 'how should I talk about this project', 'set up marketing context', 'define our voice', 'who is this for', 'how do we position this', or wants to iterate on how their project is presented. Writes .claude/product-marketing-context.md which all other brand/design skills read automatically. Supp...

Use when auditing, drafting, or refining Mission, Vision, and Tenets/Values statements. Applies Lencioni's four-type framework to classify existing tenets, enforces the label + 1-3 sentence best practice format, tests coherence across Mission→Vision→Tenets, and runs the "would you fire someone for this?" test. Invoke for leadership offsites, values workshops, or any tenet rewrite session.

You are a naming researcher. Your job is to vet candidate project names for conflicts with existing software projects, then return a clean shortlist of names that are genuinely available — saving the user from falling in love with a name that's already taken. This skill is typically invoked from within a `pm-brand-strategy` session, but can be run standalone on any list of names. ---

Guide product thinking for solo developers acting as their own PM. Use when writing PRDs, creating outcome-based roadmaps, drafting user stories with acceptance criteria, scoping features, analyzing trade-offs, or applying prioritization frameworks (RICE, MoSCoW, Kano, Jobs-to-be-Done). Covers continuous discovery and modern PM practices.

Apply evidence-based product management to roadmap decisions, feature prioritization, discovery research, PRD writing, and success metrics. Use when the user asks about what to build next, how to prioritize features, how to define a feature, how to measure success, or how to communicate product decisions. Grounded in Marty Cagan (Inspired/Empowered), Teresa Torres (Continuous Discovery Habits), Ryan Singer (Shape Up), Clayton Christensen (JTBD), and Jeff Patton (User Story Mapping).

Quickly document a new bug into docs/bugs/open/ using the project-coordinator format

Survey what's built, assess roadmap health, surface gaps, and recommend next features to prioritize

Holistic readiness check across Product, UX, and Engineering before building a feature. Supports iterative mode — re-run with fresh agents after fixing gaps until all three legs are green.

Audit the entire repository for over-engineering only, not correctness. Scan the whole tree, not a diff. One line per finding, ranked biggest cut first: <tag> <what to cut>. <replacement>. [path]. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines and dependencies removable. If nothing to cut: 'Lean already. Sh...

Harvest every `ponytail:` comment in this repository into a debt ledger so deferrals do not rot into 'later means never'. Grep the whole tree for comment markers (grep -rnE '(#|//) ?ponytail:' ., skipping node_modules/.git/build output). One row per marker, grouped by file: <file>:<line> — <what was simplified>. ceiling: <the limit named in the comment>. upgrade: <the trigger to revisit>. Tag any marker that names no upgrade path or trigger as no-trigger, those rot silently. End with the coun...

Show the ponytail gain scoreboard. One shot, change nothing: do not switch mode, write flag files, or persist anything. Render the published benchmark medians (5 everyday tasks; models Haiku, Sonnet, Opus; source benchmarks/ and the README) as plain ASCII bars: Lines of code, no-skill 100% vs ponytail 6-20% (down 80-94%); Cost, no-skill 100% vs ponytail 23-53% (down 47-77%); Speed, ponytail 3-6x faster. The bar length shows the measured range, the label carries the exact figure. These are ben...

Show the ponytail quick reference. One shot, change nothing: do not switch mode, write flag files, or persist anything. Levels: /ponytail/ponytail lite (build what's asked, name the lazier alternative in one line), /ponytail/ponytail (full, the default ladder: YAGNI then stdlib then native then one line then minimum), /ponytail/ponytail ultra (deletion before addition, challenges the requirement before building). Commands: /ponytail/review (over-engineering review of the current changes), /po...

Review the current code changes for over-engineering only, not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'

Transform resume bullets into detailed portfolio case studies

Use this agent when you need expert PostgreSQL database optimization,

Use this agent to analyze code changes in a pull request and generate

'Review pull requests and code changes for quality, design patterns,

Use this agent when you need expert guidance on presentation design,

Guide product thinking for solo developers acting as their own PM. Use

Apply evidence-based product management to roadmap decisions, feature

Find the official instruction manual/PDF for a specific owned product (by model number or photo), verify it's actually the right document (not a spec sheet or the wrong model), make sure it has a searchable text layer (OCR if it's scan-only), save it into the wiki's assets folder, and synthesize a product page that links and summarizes it. TRIGGER when the user asks to find/gather/look up a manual, instructions, or documentation for a specific tool or appliance they own, or asks how to operat...

Find, validate, and compare home renovation products (fixtures, hardware, appliances, finishes) with confirmed working image URLs and product links, plus community review and longevity research per candidate. Handles retailer bot-protection by routing image sourcing through accessible CDNs. Runs a structured discovery interview first to narrow requirements before searching. Output is a comparison table ready to paste into a wiki page or shareable email. ALWAYS trigger this skill when the user...

Use this agent to manage software projects using the AIC (ATOMIC-INVEST-CONTEXT)

Apply prompting techniques when creating prompts, agents, commands, system

How to manage Python dependencies with UV — inline script metadata (PEP 723), project mode, tool running, and when to use each approach. Always use UV; never pip directly.

Apply idiomatic, well-structured Python development practices. Use when writing, reviewing, or refactoring Python code. Covers type annotations, package management with uv, Pydantic DTOs, Typer CLIs, pytest patterns, PEP 8 style, architecture, and type-driven design.

Standards for writing standalone Python scripts — UV inline deps, loguru logging, typer CLI, exit codes, and the canonical script template. References python-dependency-management for dep management.

Comprehensive architecture review analyzing SOLID, Clean Architecture, Clean Code, DDD, and Design Patterns adherence with actionable recommendations

Review if changes are ready for commit and review

Detect dead/unused code (imports, private members, and whole-project-unreachable declarations) with language-specific tooling and a false-positive checklist before deleting anything

Identify files that are good candidates for refactoring using various metrics

Analyze tests for anti-patterns and smells, documenting issues for later remediation using project-coordinator

Post-mortem cycle that turns fixed bugs into structural enforcement. For each bug just fixed, classifies the root cause, finds the earliest possible detection point on the enforcement ladder (compile → lint → test → checklist), implements it, and verifies it would have caught the original bug. Language-agnostic. Goal is to eliminate the class, not just the instance.

High-level architecture review evaluating directional correctness, documentation quality, and FBG tech stack alignment

Create a comprehensive testing plan based on code changes

Frida dynamic instrumentation tool skill. Use when hooking functions in a running process, capturing raw payload bytes from send/recv, intercepting function arguments or return values, using Stalker for coverage tracing, or CModule for high-performance hooks. NOTE: Direct Frida attachment to Wine processes crashes — use frida-gadget.dll injection instead (documented below). Called from code-reverse-engineering-binary (Phase 5) and code-re-qt5 (Phase 3c).

Ghidra decompilation and analysis tool skill. Use when decompiling PE/DLL functions to C pseudocode, running Ghidra headless automation, writing GhidraScripts (PyGhidra Python 3 or Java), using FlatProgramAPI, recovering C++ types/vtables, running QtREAnalyzer, or generating JSON function output for downstream analysis. Called from code-reverse-engineering-binary (Phase 3) and code-re-qt5 (Phase 2).

Kaitai Struct schema authoring tool skill. Use when writing .ksy specs for binary protocols or file formats, using the expression language (instances, bit fields, process transforms, valid assertions), compiling with ksc, validating with ksv, generating Python/Rust/C++ parsers, or debugging a failing parse. Called from code-reverse-engineering-binary (Phase 7) and code-re-qt5 (Phase 4–5). Current stable: Kaitai Struct v0.11 (2025).

Network protocol capture and analysis tool skill. Use when capturing TCP/UDP traffic, extracting raw streams with tshark, analyzing packet structure, identifying message framing, or preparing binary captures for Kaitai schema authoring. Covers tcpdump, tshark (JSON output, decode-as, statistics), ngrep, USB capture, and TLS interception via ecapture for Wine targets. Called from code-reverse-engineering-binary (Phase 6) and code-re-qt5 (Phase 4).

Radare2 (r2) disassembly and analysis tool skill. Use when running r2 commands, scripting with r2pipe, analyzing functions, navigating disassembly, recovering symbols, finding cross-references, patching bytes, or using r2frida for live instrumentation. Covers r2's command language: analysis (aa/aaa/avrr), info (ii/iS/iE/ir/iee/ic), search (/w /R /v4), type system (td/to/tp), r2pipe Python API, and radiff2. Called from code-reverse-engineering-binary and code-re-qt5 (Phase 1–2 deep analysis).

Static binary triage tool skill. Use for PE/DLL/ELF triage without execution: reading PE headers, extracting imports/exports, strings, entropy, packer/compiler identification, per-section analysis, capability detection with capa, obfuscated string extraction with FLOSS, imphash, rich header fingerprinting, and .NET detection. Called from code-reverse-engineering-binary (Phase 1) and code-re-qt5 (Phase 1).