pragmatic-writing
This skill should be used when writing technical content in the style of Hunt/Thomas (The Pragmatic Programmer) and Joel Spolsky (Joel on Software). It applies when creating technical essays, documentation, tutorials, or explanatory content that needs to be clear, engaging, and actionable.
simple-tasks
Install a fast local task workflow for single-project planning with `scripts/task.sh` (claim, done, status, reporting) backed by `tasks/TASKS.md` and optional `tasks/details/` notes. Use for lightweight in-progress task coordination, not full team issue tracking.
voice-capture
This skill should be used when extracting voice profiles from sample text, creating voice documentation, or matching a specific writing style. It applies when users provide sample text and want to capture the voice for future use.
writing-orchestration
This skill should be used when orchestrating complex writing workflows with multiple phases. It provides two-agent orchestration patterns, the two-gate content readiness assessment, 10 baseline writing strategies, 20+ situational strategies, and quality checkpoints. Inspired by the Spiral Writing System.
xcode-makefiles
Install strict Xcode Makefile tooling for iOS/macOS projects, including build/run/test scripts with AGENT_NAME-based per-agent isolation under build/. Use when a project needs reproducible local CLI builds without full app scaffolding.
doc-refresh
Refresh a repo's documentation for a live production system — audit stale docs, rebuild a focused doc set with diagrams, update AI-agent knowledge bases, and improve code-level docstrings
web-scraping
This skill activates for web scraping and Actor development. It proactively discovers APIs via traffic interception, recommends optimal strategy (traffic interception/sitemap/API/DOM scraping/hybrid), and implements iteratively. For production, it guides TypeScript Actor creation via Apify CLI.
navi
Navi programming language expert. Use when writing Navi code, implementing features, handling errors, or working with Navi's type system, concurrency, and modules. Navi is a high-performance, statically-typed compiled language with modern optional types, no NULL pointer exceptions, and built-in concurrency support.
navi-stream
Navi Stream language expert for writing quantitative trading indicators and technical analysis scripts. Use when working with .nvs files, technical indicators, market data analysis, or financial computations. Navi Stream is a domain-specific language optimized for real-time streaming data processing and indicator calculations.
issue-tree-builder
McKinsey-style issue tree framework for breaking down complex problems into MECE (Mutually Exclusive, Collectively Exhaustive) components. Use when users need to decompose strategic questions, structure analysis, create work plans, or prepare for case interviews. Apply hypothesis-driven approach to problem-solving.
scpr-framework
SCPR (Situation-Complication-Problem-Recommendation) framework for structured problem solving and executive communication. Use when users need to structure strategic arguments, analyze business situations, create executive summaries, or develop clear problem statements using McKinsey-style communication. Apply when structuring recommendations, writing memos, or organizing strategic thinking.
storyline-builder
McKinsey-style storyline framework for building presentation decks. Use when users need to structure presentations, pitch decks, or strategic communications. Creates logical flow where each storyline becomes a slide title, progressing from problem to solution.
ai-use-case-scorer
Score and prioritize AI use cases for your own job. Given a list of candidate use cases (or a description of your workflow), evaluates each on Value × Feasibility × Safety and tiers them — Do Now / Do This Quarter / Park / Avoid. Use when you've heard "we should use AI more" and need to figure out what to actually build first. Built for the individual IC, not org-wide rollout.
decision-memo-builder
Builds a 1-page decision memo (context → options → recommendation → risks → ask) enforcing McKinsey memo DNA — brutal brevity, SCP storyline clarity, decision-forcing output, evidence density. Use when drafting a memo for a leadership decision, a scope cut, a buy/build/partner call, a roadmap slip, or any "should we X?" moment that needs a yes/no from a specific person by a specific date.
deck-pipeline
Multi-agent pipeline that builds a polished presentation deck from a single topic. Four agents work in sequence — Strategist defines the narrative, Builder creates the deck, Critic reviews it like a McKinsey EM, Fixer applies the top fixes. Use when you need a presentation that survives senior audiences.
hypothesis-tree
Build a Day-1 hypothesis tree — your best-guess answer to the governing question, broken into 2–3 supporting sub-hypotheses, with the test that would prove or kill each one. Different from an issue tree (which decomposes the problem space). This commits to an answer before you do the work, so the work targets what would actually change your mind. Use at the start of any analysis where you'd otherwise "boil the ocean."
mckinsey-charts
Generate McKinsey-style consulting charts as native python-pptx objects (editable inside PowerPoint). Three workhorse types — bar+callout for TAM/single-number stories, stacked column over time for revenue/usage mix, and waterfall for drivers/bridge analysis. Use when you need a chart that looks like it came from an EM-reviewed deck, not from Excel defaults.
mckinsey-critic
Reviews decks, documents, and strategies like a McKinsey engagement manager. Grades each section, flags structural problems, and gives the top 3 fixes. Use after building a deck, writing a strategy doc, or outlining a recommendation — before it goes to stakeholders.
meeting-prep-kit
Personal meeting prep tool. Given a meeting (attendees, topic, desired outcome), generates a tight prep packet — 3-bullet pre-read, time-boxed agenda, your top 3 talking points, and the top 3 objections you'll face with rebuttals. Use before any meeting where you're driving an outcome — exec reviews, stakeholder pitches, scope negotiations, manager 1:1s with an ask, vendor calls.
stakeholder-map
Map the people who can make or break a decision onto a Power/Interest grid, with each named stakeholder's stance (champion / skeptic / blocker / unknown), what they care about, and the single influence move you'll make for them. Use before any cross-functional decision, big launch, reorg, or executive ask — anywhere the politics will decide the outcome more than the merits.
synthesis
Force the "so what" out of a messy pile of raw inputs — interview notes, customer transcripts, survey results, research dumps, meeting recordings — into 3 insights with evidence and implication. Use when you have more data than you have meaning, and someone is about to ask "ok, so what does this mean?" Different from summarization; output must change how the reader acts.
top-down-memo
Answer-first writing using the Minto Pyramid Principle. Lead with the conclusion, then 2–4 MECE supporting arguments, then evidence under each. Use whenever you have a recommendation, finding, or assessment to communicate in writing — memos, emails to execs, Slack updates that need to land, briefing docs. Different from the Decision Memo Builder (which is a specific 1-page decision artifact); this is the general writing method.
workshop-designer
Design a half-day or full-day strategy workshop that ends with a committed decision and named owners — not a "great discussion" with no artifact. Outputs an hour-by-hour agenda, breakout prompts with expected outputs, pre-reads, facilitator playbook for when things go sideways, and the post-workshop artifact that justifies the day. Use for offsites, leadership alignment sessions, kickoff workshops, planning meetings >2 hours.
analyzing-regression-scope
Analyzes diffs, changed files, hotfixes, and release candidates to identify where regression risk spreads and what must be retested first. Use when scoping retest after a change, reviewing QA impact for a pull request, or building a minimal confidence suite for release validation.
api-playwright-test-developer
Writes and reviews API automation tests with Playwright Test, covering setup/teardown, assertions, data management, and hybrid API+UI flows. Use when creating backend API tests, contract checks, data-driven API coverage, API+UI hybrid workflows, or reviewing existing Playwright API suites.
auditing-accessibility
Performs webpage and user-flow accessibility audits with WCAG 2.2 guidance, manual verification checklists, prioritized remediation output, and stakeholder-ready summaries. Use when auditing accessibility on a URL, triaging suspected a11y issues, or producing technical findings with practical next steps.
code-review
Performs a quick, lightweight review of a small diff or single file, giving concise feedback on correctness, readability, tests, and obvious risks. Use when the user asks for a fast sanity-check review of a small change. For test-automation suites, architectural refactors, security-sensitive paths, or multi-file reviews, use the code-review-advanced skill instead.
code-review-advanced
Performs evidence-driven code review for pull requests, legacy modules, and quality-critical changes. Use when reviewing complex or multi-file changes, test automation suites, architectural refactors, or hot paths that need analysis of correctness, maintainability, security, performance, test quality, and operability risks. Provides structured feedback with severity-ranked findings, actionable recommendations, and clear rationale. For a fast sanity check of a small diff or single file, use the code-review skill instead.
creating-custom-agents
Creates GitHub Copilot custom agents (`.agent.md`) for VS Code. Use when defining a specialized agent role, selecting a minimal toolset, referencing supporting skills, or shipping install-ready agent examples with clear boundaries and collaboration rules.
creating-hooks
Creates GitHub Copilot hooks for VS Code using `hooks.json`, supporting scripts, and companion docs. Use when automating deterministic checks, pre/post tool policies, or reusable hook packs that need safe defaults, observability, and clear installation guidance.
creating-instructions
Creates GitHub Copilot instruction files for VS Code, including repository guidance and scoped `.instructions.md` rules. Use when encoding project conventions, choosing `applyTo` patterns, or shipping install-ready instruction examples with rationale and guardrails.
creating-prompts
Creates GitHub Copilot prompt files (`.prompt.md`) for VS Code. Use when building reusable workflow starters that route work to the right agent, collect the right inputs, and ship with install-ready templates, examples, and validation guidance.
creating-skills
Creates GitHub Copilot skills with reusable workflows, companion resources, and validation gates. Use when packaging repeatable expertise into a `SKILL.md` folder, deciding what belongs in the skill body versus resources, or producing install-ready skill examples for a team or collection.
designing-functional-tests
Designs risk-based functional test plans, manual test cases, regression slices, and automation handoff packs from requirements, URLs, or exploratory notes. Use when preparing manual QA coverage before automation, turning feature descriptions into scenario catalogs, or converting exploratory findings into structured test assets.
designing-test-data
Designs realistic, boundary-heavy, and role-aware test data packs for manual and automated testing. Use when a feature needs deliberate inputs and fixtures before execution, when edge-case values keep being improvised, or when automation needs stable example data with setup notes.
prd-generator
Produces production-ready Product Requirements Documents (PRDs) for software systems and AI-powered features, with clear problem framing, measurable outcomes, scoped functionality, testable requirements, and explicit risks. Use when the user wants to write a PRD, define requirements, plan a feature, or turn a vague product idea into an implementation-ready specification.
reporting-bugs
Transforms rough tester notes, screenshots, console output, or observed behavior into reproducible defect reports with severity, evidence, and follow-up guidance. Use when logging bugs, triaging intermittent issues, or rewriting vague defect notes into developer-ready reports.
requirements-test-coverage-mapper
Maps requirements (PRD, user stories, acceptance criteria) to test coverage via a Requirements Traceability Matrix, exposing coverage gaps, risks, test levels, prioritization, and automation candidates. Use when mapping requirements to tests, checking coverage completeness for a PRD or user story, finding missing acceptance criteria, or building a risk-based regression strategy.
static-code-analysis-typescript
Creates, reviews, and modernizes static code analysis setups for Node.js and TypeScript repositories, covering ESLint flat config, typescript-eslint, tsconfig, Prettier, import sorting, Husky, lint-staged, package.json quality scripts, and CI quality gates. Use when setting up or auditing linting, formatting, type-checking, commit hooks, or GitHub Actions quality checks in a TypeScript project.
tech-debt-analysis
Analyzes technical debt in codebases, test suites, architecture, dependencies, and delivery workflows using observable signals. Use when auditing repository health, explaining slow delivery or flaky tests, prioritizing refactoring, or building an evidence-based remediation roadmap with risk, effort, and ROI. Use when user asks for technical debt analysis, repository audit, or refactor planning.
verifying-acceptance-criteria
Compares implementation evidence against acceptance criteria and shows what is met, partial, missing, or untestable. Use when checking feature readiness, preparing QA sign-off, or turning criteria into a concrete verification matrix without inventing missing behavior.
antipattern-detector
Detect common technical and organizational anti-patterns in proposals, architectures, and plans. Use when strategic-cto-mentor needs to identify red flags before they become problems.
architecture-pattern-selector
Recommend architecture patterns (monolith, microservices, serverless, modular monolith) based on scale, team size, and constraints. Use when cto-architect needs to select the right architectural approach for a new system or migration.
assumption-challenger
Identify and challenge implicit assumptions in plans, proposals, and technical decisions. Use when strategic-cto-mentor needs to surface hidden assumptions and wishful thinking before they become costly mistakes.
clarification-protocol
Generate targeted clarifying questions (2-3 max) that challenge vague requirements and extract missing context. Use after request-analyzer identifies clarification needs, before routing to specialist agents. Helps cto-orchestrator avoid delegating unclear requirements.
cost-estimator
Infrastructure and development cost estimation for technical projects. Use when planning budgets, evaluating build vs buy decisions, or projecting TCO for architecture choices.
delegation-prompt-crafter
Transform clarified user requests into structured delegation prompts optimized for specialist agents (cto-architect, strategic-cto-mentor, cv-ml-architect). Use after clarification is complete, before routing to specialist agents. Ensures agents receive complete context for effective work.
ml-cv-specialist
Deep expertise in ML/CV model selection, training pipelines, and inference architecture. Use when designing machine learning systems, computer vision pipelines, or AI-powered features.
request-analyzer
Analyze incoming user requests to detect intent, request type (design/validate/debug/document), complexity level, and identify vague requirements or buzzwords that need clarification. Use when cto-orchestrator receives new requests that need classification before routing to specialist agents.
roadmap-generator
Generate phased implementation roadmaps with Epic/Story/Task breakdown, effort estimates, and validation checkpoints. Use when cto-architect needs to create actionable technical roadmaps from architecture designs.
Page 578 of 1706 · 85293 results
