Skills（SKILL.md）は、AIエージェント（Claude Code、Cursor、Codexなど）に特定の能力を追加するための設定ファイルです。
詳しく見る →Create distinctive brands that customers choose because they believe there's no substitute, using Marty Neumeier's Brand Gap and Zag frameworks Use when: **Building a new brand** from scratch (startup, product, service); **Repositioning an existing brand** that's become commoditized; **Defining brand differentiation** when competitors all look the same; **Creating brand guidelines** for consistent execution; **Evaluating brand strength** through structured testing
> Master Eugene Schwartz's 5 Stages of Awareness framework from "Breakthrough Advertising" (1966) to write copy that meets prospects where they are.
Master the art of calls-to-action that convert. Direct CTAs, transitional CTAs, button copy, and microcopy that turns readers into customers. Use when: Writing button text for landing pages and emails; Creating CTAs for different stages of awareness; Designing click-worthy microcopy; A/B testing CTA variations; Building email sequences with graduated CTAs
25+ proven headline formulas that stop the scroll, capture attention, and drive clicks. Templates and examples for every situation. Use when: Writing headlines for landing pages, ads, or articles; Creating email subject lines that get opens; Crafting social media hooks; A/B testing headline variations; Overcoming headline writer's block
Make your messages unforgettable using the Heath brothers' SUCCESs framework Use when: **Crafting a core message** for a product, campaign, or company that needs to stick; **Presenting complex ideas** to audiences who may forget 90% of what you say; **Writing headlines, taglines, or slogans** that people remember and repeat; **Training or educating** when retention matters more than coverage; **Pitching investors or stakeholders** where one memorable idea beats ten forgettable ones
Build high-quality backlinks systematically using Brian Dean's proven 3-step content marketing framework—find link-worthy content, make something 10x better, and reach out to the right people. Use when: **Build backlinks** to improve search rankings; **Create content** with pre-validated demand for links; **Outrank competitors** on specific topics; **Develop link-building campaigns** that actually work; **Promote new content** to relevant websites
> Transform AI-generated text into authentic, voice-consistent content — not by faking humanity, but by applying real voice patterns from a specific person or brand.
Create appropriate non-disclosure agreements for different business contexts with balanced terms and proper scope definitions
**Core principle:** Agents are non-deterministic. Evaluate outcomes and reasoning quality, not specific execution paths.
Test big ideas in just 5 days. Apply Google Ventures' proven methodology to go from problem to validated prototype without months of development. Use when: **New product concepts** that need validation before building; **Big feature decisions** with significant investment required; **Stuck teams** needing to break through analysis paralysis; **Startup pivots** when direction is uncertain; **High-risk bets** where failure is expensive
Build products customers actually want. Apply Marty Cagan's Silicon Valley-tested framework to discover solutions that are valuable, usable, feasible, and viable. Use when: **New product development** when validating what to build; **Feature prioritization** to ensure you're solving real problems; **Pivot decisions** when current direction isn't working; **Team alignment** on what problems to solve; **Risk reduction** before committing development resources
Score and qualify prospects against your Ideal Customer Profile using firmographic, technographic, and behavioral criteria
Design multi-touch outbound sequences with optimal timing, channel mix, and messaging progression for SDR campaigns
Conduct deep account and contact research to personalize outreach and identify compelling angles for engagement
Track buying signals like funding announcements, job postings, tech changes, and company news to identify sales-ready prospects
> Imagine your project has failed spectacularly—then work backward to identify why. Apply Gary Klein's "prospective hindsight" technique to catch failures before they happen.
Systematically validate your business hypotheses before building anything. Master Steve Blank's Customer Development methodology that became the foundation of Lean Startup and YC's approach. Use when: **Starting a new venture** to avoid building something nobody wants; **Before writing a line of code** to validate problem-solution fit; **Pivoting decisions** to systematically test new directions; **Early-stage fundraising** to prove market validation; **Product roadmap planning** to prioritiz...
Document your business model on one page and systematically de-risk it. Master Ash Maurya's adaptation of Business Model Canvas optimized for startups and uncertainty. Use when: **Starting a new venture** to articulate and test your business model; **Preparing for customer discovery** to document hypotheses to validate; **Pivoting decisions** to compare alternative business models; **Investor conversations** to communicate your model concisely; **Team alignment** to get everyone on the same page
Extract honest customer insights by asking questions about their life instead of your idea. Master Rob Fitzpatrick's methodology for conversations that can't lie to you. Use when: **Before building anything** to validate if the problem is real and painful; **Customer discovery calls** to get honest feedback without leading questions; **Pivoting decisions** to understand if you should change direction; **Feature prioritization** to learn what customers actually need vs. say they want; **Pricin...
Create research-backed buyer personas that drive real marketing and product decisions. Combine Buyer Personas methodology with Jobs-to-be-Done to build profiles based on actual behavior, not demographics fiction. Use when: **Starting customer discovery** to define who you're validating with; **Marketing campaign planning** to target the right messages to right people; **Content strategy** to create content that resonates with specific audiences; **Product roadmap prioritization** to build fea...
Test willingness to pay before launching with proven pricing research methodologies. Combine Van Westendorp, Gabor-Granger, and behavioral techniques to find your optimal price point. Use when: **After solution validation** to test willingness to pay; **Before launch** to set initial pricing; **Pricing changes** to test new price points; **New segments** to understand price sensitivity by segment; **Competitive positioning** to price against alternatives
Test if your solution actually solves the validated problem before building the full product. Master the art of showing concepts and prototypes to get honest feedback on solution fit. Use when: **After problem interviews** to test if your solution addresses validated problems; **Before building MVP** to validate core value proposition; **Prototype testing** to get feedback on concepts and mockups; **Feature validation** to test if new features solve real problems; **Pivoting** to test alterna...
Capture current work context for handoff to another agent/developer. Gathers git state, todos, and modified files into a structured handoff document saved to the related spec folder.
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.
Comprehensive SEO analysis skill for content optimization. Use when the user asks to perform SEO analysis, keyword research, content gap analysis, search intent analysis, or wants to optimize content for search engines. Covers topic-based keyword research (informational supply and search demand), website/document analysis, and actionable SEO recommendations. Works best with InfraNodus MCP tools for real Google data access.
This skill uses InfraNodus knowledge graph analysis to diagnose the structural diversity of a discourse and then actively shift perspective by developing underrepresented areas, bridging gaps, and sur
Uses abstract interpretation to automatically infer loop invariants, function preconditions, and postconditions for formal verification. Generates invariants that capture program behavior and support correctness proofs in Dafny, Isabelle, Coq, and other verification systems. Use when adding formal specifications to code, generating verification conditions, inferring contracts for functions, or discovering loop invariants for proofs.
Create ACSL (ANSI/ISO C Specification Language) formal annotations for C/C++ programs. Use this skill when working with formal verification, adding function contracts (requires/ensures), loop invariants, assertions, memory safety annotations, or any ACSL specifications. Supports Frama-C verification and generates comprehensive formal specifications for C/C++ code.
CLI-based browser automation with persistent page state using ref-based element interaction. Use when users ask to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.
Generate comprehensive API documentation from repository sources including OpenAPI specs, code comments, docstrings, and existing documentation. Use when documenting APIs, creating API reference guides, or summarizing API functionality from codebases. Extracts endpoint details, request/response schemas, authentication methods, and generates code examples. Triggers when users ask to document APIs, generate API docs, create API reference, or summarize API endpoints from a repository.
Generate test assertions from existing code implementation. Use when the user has implementation code without tests or incomplete test coverage, and needs assertions synthesized by analyzing the code's behavior, inputs, outputs, and state changes. Supports Python (pytest/unittest), Java (JUnit/AssertJ), and JavaScript/TypeScript (Jest/Chai). Handles equality checks, collections, exceptions, and state verification.
Compare runtime behavior between original and migrated repositories to detect behavioral differences, regressions, and semantic changes. Use when validating code migrations, refactorings, language ports, framework upgrades, or any transformation that should preserve behavior. Automatically compares test results, execution traces, API responses, and observable outputs between two repository versions. Provides actionable guidance for fixing deviations and ensuring behavioral equivalence.
Analyzes surviving mutants from mutation testing to identify why tests failed to detect them. Takes repository code, test suite, and mutation testing results as input. Identifies root causes including insufficient coverage, equivalent mutants, weak assertions, and missed edge cases. Automatically generates actionable test improvements and new test cases. Use when analyzing mutation testing results, improving test suite effectiveness, investigating low mutation scores, generating tests to kill surviving mutants, or enhancing test quality based on mutation analysis.
Instrument code to support efficient git bisect by producing deterministic pass/fail signals and concise runtime summaries for each tested commit. Use when debugging regressions with git bisect, automating bisect workflows, creating bisect test scripts, handling flaky tests during bisection, or needing clear exit codes and logging for automated bisect runs. Helps identify the exact commit that introduced a bug through automated testing.
Identify the precise location of bugs in source code, modules, and systems. Use this skill when debugging applications, investigating test failures, analyzing error reports, tracing runtime issues, or performing root cause analysis. Analyzes stack traces, error messages, failing tests, and code patterns to pinpoint buggy functions, classes, files, or modules with confidence rankings and supporting evidence.
Automatically generates executable tests that reproduce reported bugs from issue reports and code repositories. Use when users need to: (1) Create a test that reproduces a bug described in an issue report, (2) Generate failing tests from bug descriptions, stack traces, or error messages, (3) Validate bug reports by creating reproducible test cases, (4) Convert issue reports into executable regression tests. Takes a repository and issue report as input and produces test code that reliably triggers the reported bug.
Generate code fixes and patches from bug reports, failing test cases, error messages, and stack traces. Use this skill when debugging code, fixing test failures, addressing GitHub issues, resolving runtime errors, or patching security vulnerabilities. Analyzes the bug context, identifies root causes, and generates precise code patches with explanations and validation steps.
Generate GitHub Actions deployment workflows for automated deployment to staging and production environments on cloud platforms (AWS, GCP, Azure). Use when setting up continuous deployment pipelines, creating deployment automation, or configuring multi-environment deployment strategies. Includes templates for environment-specific deployments with approval gates, secrets management, and rollback capabilities.
Generate GitHub Actions CI/CD pipeline configurations for automated building and testing of library and package projects. Use when creating or updating CI workflows for npm packages, Python packages, Go modules, Rust crates, or other library projects that need automated build and test pipelines. Includes templates for common package ecosystems with best practices for dependency caching, matrix testing, and artifact publishing.
Complete partial code snippets while satisfying specified semantic constraints. Produces compilable code, verification tests, and a detailed report explaining how each constraint was satisfied.
Automatically instruments source code to collect runtime information such as function calls, branch decisions, variable values, and execution traces while preserving original program semantics. Use when users need to: (1) Add logging or tracing to code for debugging, (2) Collect runtime execution data for analysis, (3) Monitor function calls and control flow, (4) Track variable values during execution, (5) Generate execution traces for testing or profiling. Supports Python, Java, JavaScript, and C/C++ with configurable instrumentation levels.
Automatically diagnose and repair buggy code while generating comprehensive tests to verify correctness and prevent regressions.
Generate concise summaries of source code at multiple scales. Use when users ask to summarize, explain, or understand code - whether it's a single function, a class, a module, or an entire codebase. Handles function-level code by explaining intention and core logic, and large codebases by providing high-level overviews with drill-down capabilities for specific modules.
Convert code between programming languages while preserving functionality and semantics. Use when: (1) Translating functions, classes, or modules between languages (Python, JavaScript/TypeScript, Java, Go, Rust, C/C++), (2) Migrating entire projects to a different language, (3) Need idiomatic translation that follows target language conventions, (4) Converting between different paradigms (OOP to functional, etc.), (5) Porting legacy code to modern languages. Provides language-specific patterns, idiomatic translation guides, and project migration strategies.
Debug proof failures using counterexamples from Nitpick (Isabelle) or QuickChick (Coq) to identify specification errors, missing preconditions, and proof strategy issues. Use when: (1) A proof attempt fails and you need to understand why, (2) Counterexamples are generated by Nitpick or QuickChick, (3) Specifications may be incorrect or incomplete, (4) Theorems need validation before proving, (5) Missing preconditions or lemmas need identification, or (6) Proof failures need explanation and correction suggestions. Supports both Isabelle/HOL and Coq equally.
Explain why counterexamples violate specifications by analyzing formal specifications (temporal logic, invariants, pre/postconditions, code contracts), informal requirements (user stories, acceptance criteria), test specifications (assertions, property-based tests), and providing step-by-step traces showing state changes, comparing expected vs actual behavior, identifying root causes, and assessing violation impact. Use when debugging test failures, understanding model checker output, explaining runtime assertion violations, analyzing static analysis warnings, or teaching specification concepts. Produces structured markdown explanations with traces, comparisons, state diagrams, and cause chains. Triggers when users ask why something failed, explain a violation, understand a counterexample, debug a specification, or analyze why a test fails.
Generate concrete counterexamples when formal verification, assertions, or specifications fail. Use this skill when debugging failed proofs, understanding why verification fails, creating minimal reproducing examples, analyzing assertion violations, investigating invariant breaks, or diagnosing specification mismatches. Produces concrete input values, execution traces, and state information that demonstrate the failure.
Automatically generates executable test cases from model checking counterexample traces. Translates abstract counterexample states and transitions into concrete test inputs, execution steps, and assertions that reproduce property violations. Use when working with model checker outputs (SPIN, CBMC, NuSMV, TLA+, Java PathFinder, etc.) and needing to create regression tests, validate bug fixes, or reproduce verification failures in executable test suites.
Generate targeted test inputs to reach specific code paths and hard-to-reach behaviors in Python code. Use when: (1) Targeting uncovered branches or specific execution paths, (2) Need coverage-guided test generation, (3) Want to leverage LLM understanding of code semantics for meaningful test inputs, (4) Testing boundary conditions and edge cases systematically, (5) Combining symbolic reasoning with fuzzing. Provides path analysis, constraint solving, coverage-guided strategies, and LLM-driven semantic generation for comprehensive test input creation.
Automatically identify potential boundary and exception cases from requirements, specifications, or existing code, and generate comprehensive test cases targeting boundary conditions, edge cases, and uncommon scenarios. Use this skill when analyzing programs, code repositories, functions, or APIs to discover and test corner cases, null handling, overflow conditions, empty inputs, concurrent access patterns, and other exceptional scenarios that are often missed in standard testing.