tstapler
UserWeb-based mission control for running multiple AI coding agents (Claude Code, Codex, Gemini CLI, Aider) simultaneously — live dashboard, auto-approval rules, structured review queue
Categories
Indexed Skills (52)
ponytail
Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use whenever the user says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less", or "shortest path", and whenever they complain about over-engineering, bloat, boilerplate, or unnecessary dependencies.
kibitzer-check-brainstorm
Mine Claude Code session transcripts for recurring mistake patterns (not just existing kibitzer hook firings) and propose new checks kibitzer should implement, backed by cited real occurrences
kibitzer-sample-review
Find real kibitzer PostToolUse hook firings in Claude Code session transcripts and record them as categorized, checkable false-positive/true-positive samples in tstapler/kibitzer's docs/
code-archaeology
Systematically analyze external codebases by cloning git repos or extracting archives to temp dirs, then reverse-engineering the code to extract functional/non-functional requirements, identify architectural patterns, document design choices, and catalog problems worth solving. Use when asked to analyze, understand, reverse-engineer, or evaluate an unfamiliar codebase.
defense-in-depth-validation
Validate at every layer data passes through to make bugs impossible
root-cause-tracing
Systematically trace bugs backward through call stack to find original trigger
code-debugging
Systematic debugging frameworks for finding and fixing bugs - includes root cause analysis, defense-in-depth validation, and verification protocols
systematic-debugging
Four-phase debugging framework that ensures root cause investigation before attempting fixes. Never jump to solutions.
verification-before-completion
Run verification commands and confirm output before claiming success
backlog-feature-improvement
Audit the stapler-squad backlog automation/reconciliation feature — current item state, the UI, and the code — using ux:review, quality:architecture-review, code:review, and code:is-it-ready, to find gaps blocking the goal of a fully autonomous, user-configurable end-to-end delivery pipeline (e.g. letting a user pick which skills, like their SDD skills, run per item) — then routes each finding through the matching SDD entry point (sdd:fix-bug / sdd:quick / sdd:full) to research, plan, and implement the fix. Use for periodic health checks, when items report stuck/silently-failing, or when asked how to get closer to a "software factory."
commit-verify-sync
Use when asked to "push what we have," "commit and make sure CI passes," or "sync with main" — commits local changes as logical Conventional Commits, pushes to origin/main, watches the resulting CI run, and root-causes and fixes any failure (including flaky tests) before considering the work done. Not for feature branches/PRs — this repo pushes directly to main.
git-history-cutover
Drive the stapler-squad Git LFS history-rewrite cutover — reclaiming storage from bloated LFS history (docs/demos/*.gif, benchmarks/**/*.{txt,json}) via a disposable mirror clone, per-branch replay for the 90+ active worktrees, coordinated force-push to both remotes, and guided resync for every other affected clone. Use when the LFS storage quota is exceeded and blocking CI, when asked to shrink .git size from historical LFS bloat, or when picking up an in-progress cutover across sessions.
github-issue-to-backlog
Use when a request should become both a tracked GitHub issue and a stapler-squad backlog item — e.g. "file an issue for X and add it to the backlog." For feature requests, verifies no duplicate exists (backlog search + codebase check), styles the ticket body via the project-coordinator agent (AIC framework) informed by product-manager rigor (Kano/RICE, success criteria, out-of-scope, open questions), creates it with gh, then imports it into the backlog via the ImportGitHubIssue RPC.
stapler-squad-rules
Use when working in the stapler-squad repo to manage Claude Code approval rules — reviewing analytics for coverage gaps, adding or retiring rules, debugging why a session generates excessive manual review requests, or editing seed rules in pkg/classifier/classifier.go.
bedrock-model-lookup
Discover new Claude models available in AWS Bedrock and add them to the claude-proxy configuration.
code-architecture-best-practices
Apply software architecture best practices when designing or reviewing systems, classes, modules, or services. Use when structuring new code, evaluating design decisions, applying SOLID principles, Clean Architecture, Hexagonal Architecture, or Domain-Driven Design patterns. Works across languages — includes specific guidance for Python and Java/Spring Boot.
code-kmp
Idiomatic review for Kotlin Multiplatform (KMP) with Kotlin 2.x — expect/actual discipline, Swift boundary safety, ViewModel lifecycle, SQLDelight conventions
code-re-qt5
Trigger when the user asks to reverse engineer a closed-source Qt5/C++ Windows PE binary on Linux, recover Qt meta-objects (classes, signals, slots), trace Win32 API calls via Wine relay or WineDbg, hook network send/recv with Frida, capture and parse proprietary binary protocols (Wireshark → ImHex → Kaitai Struct), or analyze unknown binary file formats from embedded hardware. Also triggers for: "what does RayStudio send over the network", "recover class names from this DLL", "decode this scanner file format", "write a Kaitai struct for this protocol", or any task combining Ghidra + QtREAnalyzer, Wine WINEDEBUG relay tracing, or Frida hooking against a Wine process.
code-refactoring
Orchestrate large structural code refactors combining semantic search (ast-grep) with AST-based transformation (gritql). Use for multi-file renames, API migrations, and pattern modernization with mandatory quality gates.
code-reverse-engineering-binary
Trigger when the user asks to reverse engineer a closed-source Windows PE binary, DLL, COM server, or unknown binary format on Linux — where the target is NOT known to be Qt5. Use for: "analyze this DLL", "what does this EXE do", "decode this binary protocol", "trace Windows API calls", "find the network protocol", "reverse this file format", "hook send/recv on this process". For confirmed Qt5 targets, use code-re-qt5 instead.
code-root-cause-analysis
Systematic investigation of errors, failures, and unexpected behaviors by searching personal-wiki history and external documentation. Use when debugging errors with stack traces, investigating incidents/outages, finding historical context for similar issues, analyzing recurring problems, or searching for past solutions. Combines Logseq knowledge base (journals, pages, incident notes) with web search for external docs. Follows structured methodology to extract error signatures, search historical context, identify patterns, and determine root cause.
code-spring-boot
Apply Spring Boot and Java coding standards when writing, reviewing, or designing Java code. Use for Spring Boot project structure, DDD patterns (Entities, Aggregates, Repositories, Domain Services), Clean Code principles in Java, PoEAA patterns (Repository, Data Mapper, Service Layer, Unit of Work), testing with JUnit 5 and Mockito, and Spring-specific best practices. Covers constructor injection, transaction boundaries, layer responsibilities, and common anti-patterns to avoid.
academic-cv-builder
Format CVs for academic positions with publications, grants, and teaching
browser-profiling
Profile Chrome/JavaScript/React apps to diagnose slowness. Covers triage (load vs interaction vs scroll), Playwright-based baseline capture, React Profiler component, Chrome Performance panel interpretation, bundle analysis, memory leak detection, and fix verification. Invoke when a browser or React app is noticeably slow and you need to find and fix the bottleneck.
career-changer-translator
Translate skills from one industry to another, identify transferable skills
clothing-product-sourcer
Research, find, and compare specific clothing items (blazers, trousers, shirts, shoes, ties, pocket squares) across multiple retailers at a target price point, style, and size. Validates product availability and sources working images. Outputs a comparison table ready for a wiki page. TRIGGER when the user needs to find a specific type of clothing item, compare options across brands, or fill a gap identified during outfit planning.
code-ast-grep
Use ast-grep (sg) for semantic, syntax-aware code searching. Prefer over Grep for code pattern searches that depend on structure rather than text matching. Use when searching for function calls, class definitions, import statements, or any pattern where syntax context matters.
code-go-git
Idiomatic review for go-git/go-git v5 concurrent access. Use when reviewing Go code that imports go-git, uses git.Repository, Worktree, CommitIter, or ObjectStorage. Covers the library's documented non-thread-safety, per-repo mutex requirements, and iterator lifetime rules.
code-gritql
Use gritql (grit) for AST-based multi-file code transformations. Use when renaming methods/classes, migrating APIs, or modernizing patterns across a codebase. Always preview before applying. Pairs with ast-grep for search-then-transform workflows.
code-hotspot-analysis
Ground architecture/refactoring reviews in tool-generated evidence instead of code-reading alone — static coupling graphs (package dependency, call graph, struct/interface size) plus temporal coupling (files that change together in git history, independent of imports) combined into a complexity × churn hotspot score. The open-source technique behind CodeScene. Use before `architecture-review`/`find-refactor-candidates` to find WHERE to look; use those commands to analyze WHY once you're there.
code-java-api-discovery
Discover Java API signatures from compiled JARs using javap instead of guessing or relying on incomplete documentation. Use when encountering unknown methods, pagination patterns, union types, or compilation errors from incorrect API assumptions.
code-review
Use when receiving code review feedback (especially if unclear or technically questionable), when completing tasks or major features requiring review before proceeding, or before making any completion/success claims. Covers four practices — receiving feedback with technical rigor, requesting reviews via code-reviewer subagent, verification gates requiring evidence before claims, and security/API-compat awareness. Essential for subagent-driven development, pull requests, and preventing false completion claims.
code-strands
Best practices for the AWS Strands Agents SDK — structuring prompts, multi-agent patterns, structured I/O, and splitting monolithic agents into specialists. Use when designing or refactoring Strands-based agent systems.
cover-letter-generator
Create personalized, compelling cover letters from resume and job description
creative-portfolio-resume
Balance visual design with ATS compatibility for creative roles
design-loop
Use this skill when Tyler asks to run the design loop, fix compliance issues autonomously, iterate on the kitchen design, or when the user says 'run design:loop'. Orchestrates design:review → design:modify → design:qa in a capped cycle (max 3 iterations). DO NOT invoke for a one-shot review (use design:review) or a single spec edit (use design:modify).
design-modify
Use this skill when Tyler asks to change a specific design parameter, fix a compliance FAIL item, move the island, adjust bar seating clearance, or apply a named change to design_spec.py. Requires a specific change target (field name or FAIL item from a review). DO NOT invoke for a general compliance review (use design:review) or the full iterative loop (use design:loop).
design-patterns
Apply design patterns from Gang of Four (GoF) and Patterns of Enterprise Application Architecture (Fowler/PoEAA). Use when structuring new code, evaluating design decisions, or identifying the right pattern for a problem. Covers when to use, when to avoid, and Go-idiomatic implementations.
design-qa
Use this skill when Tyler asks to QA the current state after a manual edit, verify the pipeline ran cleanly, check whether a recent change resolves a compliance issue, or confirm the 5 PDF sheets are fresh relative to the current spec. Produces a verdict: PASS, PASS_WITH_WARNINGS, or BLOCKED. DO NOT invoke for a full review (use design:review) or the iterative loop (use design:loop).
design-review
Use this skill when Tyler asks to review the kitchen design, run compliance checks, compare the BIM drawings to the CD set, or verify owner requirements. Produces a structured Markdown compliance report with PASS/FAIL/CANNOT_VERIFY per item. Standalone — does not modify anything. DO NOT invoke for a single spec edit (use design:modify) or the full iterative loop (use design:loop).
design-validate
Use this skill to run the full 5-layer validation pipeline on the kitchen permit drawings. Combines programmatic compliance (Layer 1), SVG text extraction (Layer 2), Claude dual-pass visual layout review (Layer 3), small-element checklist (Layer 4), and human escalation flags (Layer 5). Produces a unified validation report. Use for pre-permit sign-off or after any design change. DO NOT use for a quick single-check — use design:review instead.
fix-loop
Run parallel minimal-context checks across all failure dimensions, fix everything found, and repeat until all pass or max iterations reached.
implement
Systematically implement a new feature following research-backed best practices from the Six-Phase Software Implementation Methodology, with intelligent parallelization and multi-agent coordination
is-it-ready
Shipping readiness gate — parallel swarm across plan compliance, architecture, code quality, tests, security, product/UX, and operational readiness. Produces a GO / HOLD / FIX-THEN-SHIP verdict with a mandatory auto-fix loop.
refactor
Refactor code following principles, patterns, and best practices from respected literature
review
Run the full design-doc-review pipeline (outline + readability, extensible) as parallel lean agents, then auto-fix findings in a loop with fresh unanchored re-verification each round, per the lean-agent-loop skill. Entry point for reviewing an engineering design doc / RFC.
antipatterns
Scan PostgreSQL codebase and schema for anti-patterns using postgres-optimizer agent
outline
Check a design doc / RFC's structure against the required topic set (problem, non-goals, alternatives, risks, rollout) AND verify every open question/decision ask names a decider, deadline, and default-if-silence. Flags missing or weak sections. One check in the design-doc-review pipeline — run standalone or via design-doc-review:review.
readability
Check a design doc for verbosity, buried decisions, and cognitive-load issues, scaled to the doc's stakes. One check in the design-doc-review pipeline — run standalone or via design-doc-review:review.
visuals
Check a design doc for prose that should be a diagram (architecture/sequence/flowchart/state) or a comparison table, based on mechanical structural signals in the text (step counts, participant counts, repeated comparison templates) — not taste. Does not evaluate content completeness (see design-doc-review:outline) or prose quality (see design-doc-review:readability). One check in the design-doc-review pipeline — run standalone or via design-doc-review:review.
define
Interview to define document audience, purpose, and Diataxis type — Phase 1 of the document writing workflow
parallelization-examples
Parallelization Examples and Patterns
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.