Development skills

Build sky backgrounds for 3D scenes using procedural atmosphere or panoramic images. Align the horizon, sun, shadows, and environment lighting, while handling camera movement, image loading, and smooth transitions between day, dusk, and night.

• Creating sky backgrounds for architecture and outdoor scenes
• Aligning sunset skies with shadows and reflections
• Designing transitions from day through dusk to night

Build ice and frost visual effects in Three.js using reusable modules. Combine branching frost growth, refractive ice spikes, cracks and settling fragments, freezing mist, and swirling snow into a coordinated sequence demonstrated on a snowy ground.

• Animate frost spreading across the ground
• Create erupting ice spikes that crack and shatter
• Combine freezing mist with a swirling blizzard

Create, repair, and review character combat animations, from sword strikes to bow shots and spells. Use joint measurements, mesh deformation tests, camera captures, and blind comparisons to identify awkward poses and assess changes against written rules.

• Create melee attacks, bow shots, and spell animations
• Fix stretched arms and awkward wrist or hand poses
• Define measurable combat animation rules and tests

Build and check monsters for Three.js and web action games using shared rules for joints, attachment points, collision shapes, and combat states. Separate visual animation from damage decisions, and provide reproducible checks for attacks and detail-level changes.

• Standardizing joints and attachment points across monsters
• Connecting attack timing with collision and damage handling
• Reproducing combat states and attack phase boundaries

Turn five collected UI references into five original landing pages with distinct brands, copy, and imagery. Each page gets its own Codex task and workspace, with build checks, a source commit, and private deployment through Sites.

• Build five landing pages from a UI inspiration pack
• Explore distinct brands using collected visual references
• Manage each page in a separate Codex task

Build in-game changelogs that connect release notes and displayed versions to successful production deployments. Reconstruct supported history, integrate menu navigation and accessible controls, and verify version consistency and behavior on desktop and mobile.

• Add or revise an in-game changelog screen
• Reconstruct release history from deployments and Git
• Keep displayed game versions aligned with published builds

Turn a working web effect or interaction into a reusable skill by extracting its core mechanism, documenting tested parameters and pitfalls, and packaging a demo that preserves the reference design and proves the behavior.

• Reuse a successful scroll effect across projects
• Package a canvas effect with a working demo
• Document tested parameters and hard-won fixes

Investigate slow Apple apps, memory growth, launch delays, and battery drain using Instruments and Xcode diagnostics. Choose measurements for each symptom, identify the responsible code, and compare results before and after targeted fixes.

• Investigate UI freezes and stuttering
• Find memory leaks and growing memory use
• Measure and improve app launch time

Create or revise Three.js game levels with movement kept on one flat plane. Organize routes, collision, encounters, objectives, and lighting, then verify visibility, traversal, reset behavior, and controls through desktop and mobile browser playthroughs.

• Designing flat routes and combat arenas
• Separating decoration, collision, and navigation data
• Matching local lights to visible torches or lanterns

Clean up code comments without changing executable code. The skill removes obvious explanations, decorative headings, and vague notes while preserving concise comments about intent, constraints, security, edge cases, and other information the code does not show.

• Removing comments that merely repeat the code
• Simplifying decorative headings and lengthy notes
• Preserving explanations of design decisions and constraints

Improve code through repeated changes, checks, and decisions to keep or discard each result. Start with a goal or measurable target, limit iteration counts, and review logs for progress, stalled improvements, or regressions.

• Improve code against a measurable target
• Investigate and fix recurring errors
• Check whether changes introduce regressions

Review and improve SKILL.md files using nine evaluation criteria and test prompts. Independent agents compare original and revised versions, while user checkpoints, version history, and result cards help track which changes are retained or rolled back.

• Assess skill quality without editing files
• Improve instructions in a specific SKILL.md
• Prioritize weaker skills for revision

Write and troubleshoot native Python in n8n Code nodes. Covers data filtering and transformation, migration from older Python code, valid return formats, and restricted execution environments, including cases where errors pass unprocessed input downstream.

• Filtering and aggregating data in Python Code nodes
• Migrating legacy Python (Beta) code
• Fixing input-variable and return-format errors

Configure n8n nodes by checking which fields each operation needs and which settings reveal additional options. Start with a minimal configuration, validate it, look up unclear properties, and make targeted edits to existing code or text fields.

• Checking required fields when changing a node operation
• Finding why a configuration field is hidden
• Editing part of a long code or text field

Build n8n workflows that download, transform, and send files without losing their contents. Learn how file data differs from JSON, how to preserve attachments, and how to use storage keys or URLs with AI tools and chat messages.

• Fixing attachments lost during data transformation
• Passing uploaded files to AI agent tools
• Displaying generated images in chat

Build failure handling into n8n workflows with separate error paths, retries, alerts, and clear API responses. Use it for webhooks and unattended jobs to make failures visible and return status codes that explain what went wrong.

• Add error responses to a webhook API
• Receive alerts when scheduled jobs fail
• Retry temporary external service failures

Find the specialist guidance needed to build, edit, test, or debug n8n workflows through n8n-mcp. This entry-point skill explains tool roles, directs tasks to related skills, and outlines checks for node settings, connections, outputs, and credential handling.

• Choose specialist skills for an n8n automation task
• Check live node settings before editing
• Review connections and outputs before activation

Build custom calculation and parsing tools that an n8n AI Agent can call. This skill covers JavaScript or Python inputs, structured arguments, string results, tool descriptions, and fixes for invocation and output errors.

• Adding a calculation tool to an AI Agent
• Defining typed inputs for multiple arguments
• Fixing tool output type errors

Write and troubleshoot n8n expressions, the formulas that pass and transform data between workflow steps. Correct field references, read webhook inputs, format dates and text, and query nested JSON while checking for silently missing results.

• Include webhook form data in Slack messages
• Fix expressions that return null or literal text
• Extract and total values from nested JSON

Write JavaScript for n8n Code nodes to aggregate, filter, and transform workflow data. Guidance covers data access, output formats, execution modes, common errors, and performance choices when processing large numbers of records.

• Aggregating and deduplicating multiple records
• Transforming complex API responses
• Fixing data access and return format errors

Add Preline UI components and ready-made page sections to HTML files through the Preline MCP server. The skill guides component selection, CSS and script placement, and assembly of pages containing multiple components.

• Adding a Preline UI component to an existing HTML file
• Building a page from ready-made sections
• Assembling a dashboard with multiple components

Investigate observed slowdowns or increased CPU, memory allocation, and IO costs in a process you control. Use controlled timing and runtime-specific profiling tools to test a cause, then check performance and behavior after a fix.

• Investigate a command that has become slower
• Locate CPU or memory allocation hotspots
• Separate transport waits from backend processing costs

Investigate unexpected LoopX behavior, such as stalled progress or conflicting next steps. Identify whether agent decisions, state reporting, or workflow rules caused the problem, then repair, validate, and record the correction.

• Investigating tasks that make unexpectedly little progress
• Resolving stale or contradictory next-step recommendations
• Correcting task priorities and missing follow-up work

Guides migration of historical SWE-Marathon agent configurations to the shared Codex runtime. It preserves native tasks, verification rules, and scoring while outlining environment checks and restrictions on retired execution methods.

• Migrating historical SWE-Marathon agent configurations
• Preserving task and scoring rules during migration
• Checking the native environment before a full run