Development skills

Generate configuration validators with Zod or JSON Schema, including defaults and clear validation errors. The examples show typed TypeScript schemas for nested settings, with parsing helpers that validate input or fill in defaults for partial configuration.

• Validating nested application settings
• Adding defaults to partial configuration
• Bootstrapping a CLI or MCP tool configuration

Use this skill to build a consistent color and formatting system for command-line output with chalk. It defines reusable themes and semantic styles for success, warnings, and errors, plus helpers for formatted text, boxes, and tables.

• Creating a consistent CLI color theme
• Styling success, warning, and error messages
• Formatting text, boxes, or tables in CLI output

Implement computational geometry algorithms for programming problems, including convex hulls, intersections, closest-point pairs, triangulation, and polygon tests. The skill can provide code in C++, Python, or Java, with complexity and usage details.

• Implementing a convex hull algorithm
• Solving point, line, or polygon geometry problems
• Comparing algorithm variants and complexity

Generate CLI argument validation code with type coercion, constraints, custom checks, aliases, and clear error messages. It can create schemas and normalize values for languages such as TypeScript, Python, Go, and Rust.

• Validating CLI argument types and ranges
• Adding custom checks for command inputs
• Normalizing aliases and input values

Generate segment tree code for range queries and updates using a chosen merge function. Select basic, lazy propagation, persistent, 2D, or other advanced variants, along with an implementation style and supported programming language.

• Implementing range queries with custom merge logic
• Adding range updates with lazy propagation
• Choosing a persistent or 2D segment tree variant

Scaffold a Go command-line application with Cobra commands and Viper configuration. Generate a project layout with shared and local flags, environment variable binding, shell completion, and build setup based on the requested commands.

• Starting a new Go CLI project
• Designing commands and subcommands
• Adding shared flags and configuration

Use this skill to optimize code for competitive programming in C++, Python, or Java. It suggests language-specific changes to input handling, memory use, loops, and data layout, with an option to preserve readability and a list of applied optimizations.

• Speeding up a competitive programming solution
• Reducing input and output overhead
• Reviewing memory use and data layout

Configure cosmiconfig to find application settings across supported file names and formats. Set search paths, add loaders for formats such as TypeScript, combine loaded values with defaults, and handle caching and validation.

• Adding configuration discovery to a Node.js app
• Supporting JSON, YAML, or TOML settings
• Loading TypeScript configuration files

Configure Vite to bundle an MCP App as one self-contained HTML file, inlining JavaScript, CSS, images, and fonts for use in a sandboxed iframe. Set up entry points and build scripts, including separate UI and server build phases.

• Building an MCP App for a sandboxed iframe
• Inlining app assets into one HTML file
• Adding a separate MCP build beside a standalone web build

Get implementations and guidance for advanced data structures used in competitive programming and complex algorithm problems. The skill covers balanced trees, persistent structures, tree decompositions, and range-query tools, with usage notes and complexity information.

• Implementing a treap or splay tree
• Answering range queries with a wavelet tree
• Handling dynamic tree operations

Match a dynamic programming problem to a known pattern, then get guidance on states, transitions, variants, and optimizations. Generate commented Python, C++, or Java templates, including space-optimized versions, to help turn a recognized approach into code.

• Mapping a problem statement to a DP pattern
• Getting a template for a recognized problem
• Choosing states and transition rules

Design dynamic programming solutions by identifying subproblems, defining the state parameters, deriving transitions and base cases, and choosing a computation order. It can also estimate state space complexity and suggest memory optimizations such as rolling arrays or bitmask compression.

• Define states for a dynamic programming problem
• Derive transition formulas and base cases
• Estimate complexity and explore memory optimizations

Build the core Tool and Resource pattern for MCP Apps: connect tools to UI resources, pass structured data to the interface, and provide text responses for hosts without UI support. Includes app-only helper tools and shared resources.

• Connecting an MCP tool to an interactive UI resource
• Providing structured data and a text fallback
• Adding UI-only tools for pagination or updates

Measure code runtime, memory use, and cache behavior to locate hot spots and possible bottlenecks. The skill can compare implementations and suggest optimizations, using tools such as gprof, perf, Valgrind, cProfile, or language-specific profilers when available.

• Finding slow functions or lines
• Investigating high memory use
• Comparing algorithm implementations

Choose a data structure by comparing the operations a program needs, how often they occur, and time or memory limits. Get a recommendation with complexity estimates, alternatives, trade-offs, and possible extensions for custom requirements.

• Choose a structure for insert, delete, and search
• Compare options for range queries and updates
• Balance runtime and memory constraints

Set up an MCP App project with its server and UI entry points, dependencies, build scripts, and directory layout. Choose templates for React, Vanilla JS, Vue, Svelte, Preact, or Solid, using the SDK’s reference code to guide the scaffold.

• Starting a new MCP App project
• Choosing a framework for an MCP App UI
• Creating server and client entry points

Turn optimization problems into flow networks by defining nodes, edges, sources, and sinks. The skill selects suitable methods for maximum flow, minimum cuts, bipartite matching, minimum-cost flow, and circulation problems.

• Model an assignment problem as bipartite matching
• Represent scheduling constraints with a flow network
• Find a maximum flow or minimum cut

Calculate combinatorial values for programming problems, including permutations, combinations, factorials, and special number sequences. Apply modular arithmetic and techniques such as Lucas theorem and inclusion-exclusion to handle counting tasks.

• Calculating nCr or nPr under a modulus
• Computing Catalan, Stirling, or Bell numbers
• Handling large combination counts with Lucas theorem

Analyze code to estimate how its running time and memory use grow as inputs get larger. The skill examines loops, recursion, calls, and data structures, then provides Big-O results with derivations and possible optimization ideas across several programming languages.

• Checking an algorithm’s time and space costs
• Comparing multiple implementations
• Finding loop or recursion bottlenecks

Integrate an MCP App UI with its host’s theme, fonts, and layout context. Apply host CSS variables with fallbacks, respond to theme changes, account for embedded safe areas, and configure embedded or fullscreen display modes.

• Matching an MCP App to its host’s colors and fonts
• Updating the UI when the host theme changes
• Adding safe area padding in embedded views

Manage reusable competitive programming templates in C++, Python, and Java. Retrieve or organize algorithm and data structure snippets, customize a personal library, and generate problem specific starter code for contests.

• Prepare fast input and output code for a contest
• Retrieve a segment tree or graph algorithm template
• Generate starter code for a specific problem

Define and document project-wide principles for how a team works, including development practices, code quality, testing, UX, performance, security, and architecture. Use it to formalize existing standards or set governance before planning a new feature area.

• Documenting existing team standards
• Updating project governance as it evolves
• Setting principles before a new feature specification

Execute a written implementation plan in a separate session, handling tasks in batches and reporting for review between them. It supports resuming saved tasks, setting up a worktree, and finishing the branch after the plan is complete.

• Run a written implementation plan in batches
• Review progress between task groups
• Resume saved tasks in a separate session

Compare project rules, specifications, plans, and tasks before implementation. This skill maps requirements to planned work, flags missing coverage and conflicting instructions, checks acceptance criteria, and reports whether the artifacts are consistent and ready for implementation.

• Checking that every requirement has a matching task
• Finding conflicts between project rules and a plan
• Assessing readiness before implementation begins