Repo code improvement skills

Inventory of the skills available under E:\99--skills, grouped by domain and by working intent.

This page is an inventory of the 95 skills available under E:\99--skills. They are grouped two ways — by domain (Category groups) and by working intent (Categorized by intent) — followed by an alphabetical catalog with a one-line description of each skill.

Category groups

Agent operating discipline and Waza skills: using-superpowers, waza-check, waza-design, waza-health, waza-hunt, waza-learn, waza-read, waza-think, waza-write.
Research, market, and repository investigation: competitive-brief, extracting-capability, metrics-review, oss-discovery, repo-compatibility-investigator, repo-investigator-v2.0, product-brainstorming, research-synthesis, synthesize-research, user-research.
Planning, architecture, and lifecycle control: _architecture, system-design, write-spec, initiating-a-new-task, investigating-and-writing-plan, evaluating-plan-before-implementation, executing-approved-plans, executing-plans, taking-over-investigation-and-plan, address-evaluation-results, addressing-evaluation-findings, evaluating-implemented-plan, blind-implementation-review, writing-plans, writing-frontend-design-instruction, generate-fdsc, initiating-frontend-design.
UX, frontend design, and Figma: accessibility-review, design-critique, design-handoff, design-system, designing-from-layout-contract, extracting-platform-page-contract, figma-code-connect-components, figma-create-design-system-rules, figma-create-new-file, figma-generate-design, figma-generate-library, figma-implement-design, figma-use, frontend-foundation-audit, frontend-foundation-designer, measuring-layouts-with-playwright, ux-copy.
Development, code quality, testing, and operations: capability-liftout, cli-developer, code-review, comprehensive-systematic-debugging, debug, deploy-checklist, finishing-a-development-branch, receiving-code-review, requesting-code-review, systematic-debugging, test-driven-development, testing-strategy, verification-before-completion, incident-response, runbook, change-request.
Data, SQL, analytics, and visualization: build-dashboard, create-viz, data-context-extractor, data-visualization, explore-data, sql-queries, statistical-analysis, supabase-postgres-best-practices, validate-data, write-query.
Documentation, process, and writing: doc-coauthoring, documentation, process-doc, process-optimization, proposal-writing, standup, writing-clearly-and-concisely.
Skill systems, memory, and security tooling: mcp-builder, memory, memory-hygiene, pm-protocol, prompt-guard, self-improvement, skill-creator, skill-vetter, writing-skills.

Alphabetical catalog

_architecture (Planning, architecture, and lifecycle control). Use this skill to create or evaluate an architecture decision record, compare technical options, document tradeoffs, or review a proposed component design against requirements and constraints. It fits decisions where the team needs a recorded rationale rather than a loose recommendation.
accessibility-review (UX, frontend design, and Figma). Use this skill to audit a page, mockup, or design against WCAG 2.1 AA concerns such as contrast, keyboard access, touch targets, focus order, and screen reader behavior. It turns accessibility review into a structured pass before handoff or release.
address-evaluation-results (Planning, architecture, and lifecycle control). Use this skill after an evaluation produces findings that need disposition against a plan, implementation, and current repo reality. It forces each finding through verification, classification, root-cause analysis, and evidence-backed reporting before any fix proceeds.
addressing-evaluation-findings (Planning, architecture, and lifecycle control). Use this skill for the same evaluation-remediation workflow as address-evaluation-results, especially when findings come from plan evaluation or implementation compliance review. It prevents blind agreement with evaluator output by checking whether each claim is confirmed, contradicted, obsolete, over-scoped, or unverifiable.
blind-implementation-review (Planning, architecture, and lifecycle control). Use this skill when a reviewer needs to assess recently implemented code without relying on the original plan or prior context. It reconstructs intent from the code itself and focuses on correctness, safety, maintainability, and gaps that a plan-driven review might miss.
build-dashboard (Data, SQL, analytics, and visualization). Use this skill to turn data into a self-contained interactive HTML dashboard with charts, filters, tables, and KPI cards. It is aimed at stakeholder-ready snapshots where people need to inspect results in a browser without a full application.
capability-liftout (Development, code quality, testing, and operations). Use this skill when adopting, borrowing, or porting a subsystem from another repository and the team needs exact boundaries before copying code. It defines what to take, what to shim, what to replace, and what license or dependency risks must be resolved.
change-request (Development, code quality, testing, and operations). Use this skill to write a change management request with impact analysis, rollout plan, rollback plan, and stakeholder communication notes. It fits changes that need approval, audit trail, or operations coordination before deployment.
cli-developer (Development, code quality, testing, and operations). Use this skill when building command-line tools, argument parsers, interactive prompts, progress output, or shell completions. It emphasizes CLI ergonomics, predictable behavior, and implementation patterns across common CLI stacks.
code-review (Development, code quality, testing, and operations). Use this skill to review a diff or pull request for correctness, security, performance, missing edge cases, and maintainability. It leads with findings and evidence rather than a general summary.
competitive-brief (Research, market, and repository investigation). Use this skill to compare competitors, feature areas, or market positions for product strategy, sales enablement, investor materials, or roadmap decisions. It organizes the output around differentiation, parity, evidence, and next moves.
comprehensive-systematic-debugging (Development, code quality, testing, and operations). Use this skill for bugs, failing tests, or unexpected behavior when plan compliance may also be in question. It combines reproduce-isolate-diagnose discipline with lifecycle awareness so fixes address the root cause and the approved contract.
create-viz (Data, SQL, analytics, and visualization). Use this skill to create publication-quality charts from query results, DataFrames, or analytical outputs. It guides chart choice, visual clarity, accessibility, and whether the result should be static or interactive.
data-context-extractor (Data, SQL, analytics, and visualization). Use this skill to generate or improve a company-specific data analysis skill from schemas, metrics, analyst knowledge, and warehouse conventions. It supports both bootstrap mode for new data context and iteration mode for adding domain knowledge.
data-visualization (Data, SQL, analytics, and visualization). Use this skill when building charts with Python libraries such as matplotlib, seaborn, or plotly. It focuses on readable visual encodings, chart selection, color, accessibility, and the match between data shape and message.
debug (Development, code quality, testing, and operations). Use this skill for a structured debugging session when behavior diverges from expectations and the cause is not clear. It prioritizes reproduction, isolation, diagnosis, and a root-cause fix before broader verification.
deploy-checklist (Development, code quality, testing, and operations). Use this skill before shipping a release, especially when migrations, feature flags, approvals, rollback triggers, or production readiness checks matter. It turns deployment into a checklist with explicit preflight and rollback evidence.
design-critique (UX, frontend design, and Figma). Use this skill to review a mockup, screenshot, or design for usability, hierarchy, consistency, and clarity. It works for early design feedback and final polish because it separates concrete issues from subjective preference.
design-handoff (UX, frontend design, and Figma). Use this skill when a design is ready for engineering and needs implementation-ready specs. It covers layout, tokens, component props, interaction states, responsive behavior, edge cases, and animation notes.
designing-from-layout-contract (UX, frontend design, and Figma). Use this skill to turn measured browser layout captures into a fixed reproduction contract. It is for page parity work where the implementer needs viewport-specific measurements, screenshots, and explicit allowances for only requested changes.
design-system (UX, frontend design, and Figma). Use this skill to audit, document, or extend a design system. It helps find hardcoded values, naming drift, missing component states, accessibility gaps, and patterns that need to fit existing tokens and conventions.
doc-coauthoring (Documentation, process, and writing). Use this skill when a user wants to co-author documentation, proposals, specs, or decision docs through structured iteration. It helps transfer context, shape the document for its readers, and verify that the finished doc works.
documentation (Documentation, process, and writing). Use this skill to write or maintain technical documentation such as README files, API docs, architecture docs, runbooks, and onboarding guides. It starts from reader needs and keeps the output direct, current, and reusable.
evaluating-implemented-plan (Planning, architecture, and lifecycle control). Use this skill after implementation appears complete and the work needs a plan-compliance audit before approval or handoff. It checks whether current code, tests, and evidence satisfy the approved plan rather than whether the code merely looks plausible.
evaluating-plan-before-implementation (Planning, architecture, and lifecycle control). Use this skill when a drafted implementation plan needs approval before execution. It checks structural completeness, locked decisions, architecture quality, repo reality, verification steps, and whether the plan is safe to hand to an implementer.
executing-approved-plans (Planning, architecture, and lifecycle control). Use this skill when an implementation plan has been approved and must be executed as a contract. It tracks manifest items, locked decisions, inventory counts, acceptance criteria, drift, and evidence while code changes happen.
executing-plans (Planning, architecture, and lifecycle control). Use this skill when a written implementation plan needs execution in a separate session with review checkpoints. It is lighter than the full approved-plan contract but still keeps the work tied to the plan.
explore-data (Data, SQL, analytics, and visualization). Use this skill to profile a new table, file, or dataset before drawing conclusions. It checks shape, nulls, distributions, duplicates, suspicious values, and candidate dimensions or metrics for analysis.
extracting-capability (Research, market, and repository investigation). Use this skill when lifting a coherent capability from a source repo into a target repo, especially across language, adapter, or license boundaries. It produces a cut plan with take-list, seam register, shim spec, dependency map, license map, port order, risks, and validation.
extracting-platform-page-contract (UX, frontend design, and Figma). Use this skill to extract a deterministic platform design package from a single live page. It captures shell behavior, tokens, typography, spacing, responsive patterns, and visible component inventory without crawling unrelated routes.
figma-code-connect-components (UX, frontend design, and Figma). Use this skill to map Figma design components to code components through Code Connect. It is for linking component APIs, variants, and implementation details so design and code stay aligned.
figma-create-design-system-rules (UX, frontend design, and Figma). Use this skill to generate project-specific design system rules for Figma-to-code workflows. It establishes naming, token, component, and implementation conventions from the codebase and design system context.
figma-create-new-file (UX, frontend design, and Figma). Use this skill to create a new Figma or FigJam file before further design work. It handles file creation and plan resolution so later Figma actions have a valid target.
figma-generate-design (UX, frontend design, and Figma). Use this skill with figma-use when translating an application screen, page, or layout into Figma. It discovers design system components, imports styles, and builds screens section by section with tokens instead of hardcoded values.
figma-generate-library (UX, frontend design, and Figma). Use this skill to build or update a professional Figma design system from a codebase. It covers tokens, variables, components, theming, foundations, documentation, and gaps between code and design assets.
figma-implement-design (UX, frontend design, and Figma). Use this skill when implementing production UI code from Figma designs. It focuses on visual fidelity, component structure, responsive behavior, and translating design specs into maintainable application code.
figma-use (UX, frontend design, and Figma). Use this skill before any Figma MCP write action or JavaScript-backed file inspection. It teaches the safe calling pattern for creating, editing, deleting, inspecting, or binding Figma nodes, variables, and components.
finishing-a-development-branch (Development, code quality, testing, and operations). Use this skill when implementation is complete, tests pass, and the team needs to decide how to integrate the branch. It presents structured options for merge, pull request, cleanup, or handoff.
frontend-foundation-audit (UX, frontend design, and Figma). Use this skill to assess a repo frontend foundation before writing a canonical contract. It inspects shell ownership, navigation, tokens, themes, components, page patterns, and state presentation from current code.
frontend-foundation-designer (UX, frontend design, and Figma). Use this skill to turn a reference web page into a foundational React page inside a Vite, React, and Tailwind host app. It is for refined in-house starting points, not full marketing-page clones or shell-inclusive reproductions.
generate-fdsc (Planning, architecture, and lifecycle control). Use this skill to generate a Full Design Spec and Code package after frontend readiness has been confirmed from an approved implementation plan. It produces reviewable TSX, CSS, fixtures, state coverage, and typed integration seams before live backend dependency.
incident-response (Development, code quality, testing, and operations). Use this skill during production incidents, alert triage, stakeholder updates, and postmortems. It structures severity assessment, communication, mitigation, resolution evidence, and blameless follow-up.
initiating-a-new-task (Planning, architecture, and lifecycle control). Use this skill at the start of a new engineering task when the user gives only a short intent. It silently gathers repo context, constraints, prior plans, and related work, then proposes the right lifecycle route and only the necessary clarifying questions.
initiating-frontend-design (Planning, architecture, and lifecycle control). Use this skill after an approved implementation plan has frontend impact and the team needs to decide the frontend design route. It extracts affected pages, routes, shell impact, reuse candidates, style inputs, and whether the plan is ready for FDSC generation.
investigating-and-writing-plan (Planning, architecture, and lifecycle control). Use this skill when a multi-step task needs a plan before code changes. It verifies repo reality, locks API, data, frontend, observability, compatibility, and acceptance surfaces, then produces an implementation-ready plan.
mcp-builder (Skill systems, memory, and security tooling). Use this skill to build high-quality Model Context Protocol servers for external APIs or services. It guides tool design, resource shape, transport choices, and implementation patterns for Python FastMCP or Node TypeScript MCP SDK servers.
measuring-layouts-with-playwright (UX, frontend design, and Figma). Use this skill when a live webpage needs a deterministic viewport measurement pass. It captures screenshots, computed styles, layout boxes, and browser-rendered evidence for parity specs or rebuilds.
memory (Skill systems, memory, and security tooling). Use this skill for persistent agent memory, context recovery, remembered decisions, and survival across context compaction. It combines behavioral save rules, auto-capture, keyword recall, session state, recent context, and consolidation scripts.
memory-hygiene (Skill systems, memory, and security tooling). Use this skill to audit, clean, and optimize vector memory when recall is noisy, bloated, expensive, or stale. It focuses on keeping stored context useful without flooding future sessions.
metrics-review (Research, market, and repository investigation). Use this skill to review product metrics over a time period, investigate spikes or drops, compare against targets, and turn raw numbers into an action-oriented scorecard. It is suited to weekly, monthly, and quarterly business reviews.
oss-discovery (Research, market, and repository investigation). Use this skill to find open-source projects, libraries, or tools that fit a desired feature and the current stack. It searches broadly, compares maintenance, license, compatibility, integration cost, and recommends adopt, borrow, fork, avoid, or build.
pm-protocol (Skill systems, memory, and security tooling). Use this skill when a repo issue needs PM or director mode rather than more local explanation. It fits stalled work, vague handoffs, large implementations, runtime recovery, configuration confusion, multi-agent coordination, and worker-output evaluation.
process-doc (Documentation, process, and writing). Use this skill to document a business process with steps, exceptions, ownership, RACI, and SOP details. It turns implicit operational knowledge into a repeatable process artifact.
process-optimization (Documentation, process, and writing). Use this skill to analyze and improve slow, overloaded, or confusing business workflows. It identifies bottlenecks, waste, unnecessary handoffs, and practical changes to reduce friction.
product-brainstorming (Research, market, and repository investigation). Use this skill to explore product ideas, problem spaces, assumptions, and solution directions with a PM-style thinking partner. It helps generate options, challenge weak premises, and converge on a direction.
prompt-guard (Skill systems, memory, and security tooling). Use this skill to design or apply prompt injection defenses for AI agents. It covers direct and indirect injection detection, severity scoring, logging, policy configuration, and HiveFence-style threat intelligence integration.
proposal-writing (Documentation, process, and writing). Use this skill to create funding proposals, grant submissions, pitch narratives, or investment memos from source documents. It extracts source-specific material, finds gaps, prioritizes evidence, and shapes a coherent proposal.
receiving-code-review (Development, code quality, testing, and operations). Use this skill when acting on code review feedback, especially when the comments are unclear, questionable, or may be wrong. It requires technical verification before agreement or implementation.
repo-compatibility-investigator (Research, market, and repository investigation). Use this skill to produce a concise investigation brief for an external repository through the lens of the current repo's needs. It profiles both sides, cites exact file evidence, and ends with a borrowing or adoption verdict.
repo-investigator-v2.0 (Research, market, and repository investigation). Use this skill to analyze, compare, or understand repositories, their stacks, architecture, features, and fit. It is broader than compatibility review and suits external repo analysis, comparison, and learning tasks.
requesting-code-review (Development, code quality, testing, and operations). Use this skill when completing a task, major feature, or branch and requesting a review before merge. It prepares the review context, requirements, evidence, and focus areas reviewers need.
research-synthesis (Research, market, and repository investigation). Use this skill to synthesize interviews, surveys, usability notes, support tickets, or NPS comments into themes, user segments, and recommendations. It turns raw research into prioritized product or design insight.
runbook (Development, code quality, testing, and operations). Use this skill to create or update an operational runbook for a recurring task. It captures prerequisites, commands, procedure, troubleshooting, rollback, and escalation paths for repeatable operations.
self-improvement (Skill systems, memory, and security tooling). Use this skill to capture errors, corrections, failed commands, missing capabilities, outdated assumptions, and better recurring approaches. It turns mistakes and discoveries into reusable learnings for future sessions.
skill-creator (Skill systems, memory, and security tooling). Use this skill when creating or updating a skill that extends an agent with specialized knowledge, workflows, or tool integrations. It guides structure, trigger clarity, references, scripts, and verification before deployment.
skill-vetter (Skill systems, memory, and security tooling). Use this skill before installing a skill from ClawdHub, GitHub, or another source. It checks for suspicious instructions, excessive permission scope, unsafe code, and other security red flags.
sql-queries (Data, SQL, analytics, and visualization). Use this skill to write, translate, or optimize analytical SQL across common warehouse dialects. It covers CTEs, joins, window functions, aggregations, dialect differences, and performance concerns.
standup (Documentation, process, and writing). Use this skill to turn recent work into a daily standup update. It organizes notes into yesterday, today, blockers, and shareable progress without bloating the update.
statistical-analysis (Data, SQL, analytics, and visualization). Use this skill to apply descriptive statistics, trend analysis, outlier detection, correlations, and hypothesis testing. It helps interpret distributions and decide whether conclusions are statistically supported.
supabase-postgres-best-practices (Data, SQL, analytics, and visualization). Use this skill when writing, reviewing, or optimizing Postgres queries, schema designs, and database configuration in Supabase contexts. It focuses on performance, safe schema choices, and operational database patterns.
synthesize-research (Research, market, and repository investigation). Use this skill to synthesize interviews, surveys, support feedback, or other research inputs into ranked themes and actionable recommendations. It overlaps with research-synthesis but emphasizes making sense of a large feedback pile.
systematic-debugging (Development, code quality, testing, and operations). Use this skill before proposing fixes for bugs, failing tests, or unexpected behavior. It enforces reproduction, one-change-at-a-time diagnosis, root-cause tracing, and verification against the original symptom.
system-design (Planning, architecture, and lifecycle control). Use this skill to design systems, services, APIs, data models, and service boundaries. It fits architecture questions where the output needs a direct system shape rather than only implementation tasks.
taking-over-investigation-and-plan (Planning, architecture, and lifecycle control). Use this skill when inheriting a draft, prior investigation, stale notes, or partial implementation. It verifies what still matches reality, salvages what is useful, and decides whether to continue, amend, or replace the existing plan.
test-driven-development (Development, code quality, testing, and operations). Use this skill before implementing a feature or bugfix when a test-first workflow is appropriate. It drives red-green-refactor discipline and confirms regression tests fail before the fix and pass afterward.
testing-strategy (Development, code quality, testing, and operations). Use this skill to design a test plan, coverage approach, or test architecture for a feature, service, or workflow. It helps decide which unit, integration, end-to-end, contract, and manual checks matter.
user-research (Research, market, and repository investigation). Use this skill to plan, conduct, and synthesize user research. It supports research questions, interview guides, surveys, usability tests, and methods for understanding user needs.
using-superpowers (Agent operating discipline and Waza skills). Use this skill at the start of work to identify which skills apply and load them before acting. It is the meta-skill that prevents skipping the workflow discipline encoded in the skill library.
ux-copy (UX, frontend design, and Figma). Use this skill to write or review microcopy, error messages, empty states, CTAs, onboarding text, and confirmation dialogs. It aims for clear, useful wording at the exact point where users need guidance.
validate-data (Data, SQL, analytics, and visualization). Use this skill to QA an analysis before sharing it. It checks methodology, aggregation logic, query results, bias, assumptions, and whether conclusions are supported by the data.
verification-before-completion (Development, code quality, testing, and operations). Use this skill before making any claim that work is complete, fixed, passing, or ready. It requires fresh verification commands, full output review, exit-code checks, and evidence before success language.
waza-check (Agent operating discipline and Waza skills). Use this skill after implementation or before merge to inspect the diff, run targeted checks, and escalate larger diffs to specialist reviewers. It is for completion review, not brainstorming or root-cause debugging.
waza-design (Agent operating discipline and Waza skills). Use this skill when building UI, pages, components, or visual interfaces. It pushes the work toward a committed aesthetic, domain-appropriate controls, and non-generic design decisions.
waza-health (Agent operating discipline and Waza skills). Use this skill when the agent environment, instruction stack, hooks, or MCP servers behave inconsistently. It audits configuration layers and flags environment issues by severity.
waza-hunt (Agent operating discipline and Waza skills). Use this skill for errors, crashes, failing tests, and unexpected behavior where root cause must be found before patching. It is a debugging discipline skill, not a code review or feature-building skill.
waza-learn (Agent operating discipline and Waza skills). Use this skill for research articles, unfamiliar domains, and source-heavy learning tasks that need collection, digestion, outline, drafting, refinement, and publishing. It is too heavy for quick lookups.
waza-read (Agent operating discipline and Waza skills). Use this skill when given a URL, web page, or PDF that needs to be fetched and read. It defines a proxy cascade for clean Markdown extraction and is not for local repo files.
waza-think (Agent operating discipline and Waza skills). Use this skill before writing code for a new feature, design, or architecture decision. It turns rough intent into an approved plan with enough structure to implement safely.
waza-write (Agent operating discipline and Waza skills). Use this skill when asked to write, edit, or polish English or Chinese prose. It strips common AI writing patterns, preserves content unless told to cut, and outputs the revised prose without extra explanation.
write-query (Data, SQL, analytics, and visualization). Use this skill to turn a natural-language data need into optimized SQL for a specific dialect. It helps build multi-CTE queries, joins, aggregations, and warehouse-specific syntax.
write-spec (Planning, architecture, and lifecycle control). Use this skill to turn a vague product idea or problem statement into a structured feature spec or PRD. It defines goals, non-goals, acceptance criteria, success metrics, and phased scope.
writing-clearly-and-concisely (Documentation, process, and writing). Use this skill to apply concise writing rules to prose that humans will read, including documentation, explanations, error messages, and reports. It removes clutter and strengthens sentence structure.
writing-frontend-design-instruction (Planning, architecture, and lifecycle control). Use this skill after an approved implementation plan has frontend surface area but lacks clear design direction. It writes the design instruction needed before frontend execution begins.
writing-plans (Planning, architecture, and lifecycle control). Use this skill when requirements or a spec need to become a multi-step plan before code changes. It keeps planning ahead of implementation and defines what must be checked before work begins.
writing-skills (Skill systems, memory, and security tooling). Use this skill when creating, editing, or verifying skills before deployment. It focuses on trigger clarity, progressive disclosure, supporting references, scripts, examples, and tests that prove the skill works.

Categorized by intent

The catalog above groups skills by domain. This section re-groups the same 95 entries by what you are trying to do — the working intent — across seven macro-areas. Every entry appears exactly once. A few skills could reasonably sit in two places; those judgment calls are noted at the end.

A. Coding and engineering

Building and implementing — cli-developer
Debugging — debug, systematic-debugging, comprehensive-systematic-debugging, waza-hunt
Testing — test-driven-development, testing-strategy
Code review (giving and receiving) — code-review, requesting-code-review, receiving-code-review, blind-implementation-review, waza-check
Verification and branch completion — verification-before-completion, finishing-a-development-branch

B. Data and analytics

SQL and data wrangling — sql-queries, write-query, supabase-postgres-best-practices, explore-data, validate-data, statistical-analysis, data-context-extractor
Visualization and dashboards — build-dashboard, create-viz, data-visualization

C. Thinking, planning, and lifecycle

Thinking and brainstorming — product-brainstorming, waza-think
Writing plans — writing-plans, investigating-and-writing-plan, taking-over-investigation-and-plan, initiating-a-new-task
Evaluating plans and implementations — evaluating-plan-before-implementation, evaluating-implemented-plan, address-evaluation-results, addressing-evaluation-findings
Executing plans — executing-plans, executing-approved-plans
Architecture and system design — _architecture, system-design, write-spec

D. Design and frontend

Frontend design and build — accessibility-review, design-critique, design-system, design-handoff, ux-copy, waza-design
Frontend foundations and contracts — frontend-foundation-audit, frontend-foundation-designer, extracting-platform-page-contract, designing-from-layout-contract, measuring-layouts-with-playwright, writing-frontend-design-instruction, initiating-frontend-design, generate-fdsc
Figma integration — figma-use, figma-create-new-file, figma-generate-design, figma-generate-library, figma-code-connect-components, figma-create-design-system-rules, figma-implement-design

E. Writing and communication

Writing better (prose quality) — writing-clearly-and-concisely, waza-write
Documentation — documentation, doc-coauthoring
Process and business writing — process-doc, process-optimization, proposal-writing, standup

F. Research and investigation

Repo investigation and capability adoption — repo-investigator-v2.0, repo-compatibility-investigator, oss-discovery, extracting-capability, capability-liftout
Market and user research — competitive-brief, metrics-review, user-research, research-synthesis, synthesize-research
Reading and learning — waza-read, waza-learn

G. Agent infrastructure and operations

Skill and agent building — skill-creator, writing-skills, mcp-builder, skill-vetter
Memory and self-improvement — memory, memory-hygiene, self-improvement
Agent discipline and safety — using-superpowers, pm-protocol, prompt-guard, waza-health
Deployment and operations — deploy-checklist, incident-response, runbook, change-request

Dual-home judgment calls

These entries had a plausible second home; the chosen placement is listed first.

ux-copy → Frontend design and build (over Writing better) — it is UI text written at the point of interaction.
generate-fdsc → Frontend foundations and contracts (over Building and implementing) — it produces a frontend spec-and-code package.
product-brainstorming → Thinking and brainstorming (over Market and user research).
change-request, runbook, incident-response → Deployment and operations (over Process and business writing / Debugging) — they are operational artifacts.
write-spec → Architecture and system design (over Writing plans) — it defines the product contract, not the build steps.

Repo code improvement skills

On this page