SKILLS

A three-layer method — spec, verifier, environment — that keeps an AI coding agent honest on anything bigger than a one-file edit.

I run this on every non-trivial build: interview down to the real goal, write measurable pass/fail criteria before any code exists, and keep the workshop — instructions, skills, tool-level guardrails — durable across sessions. It also runs in reverse as a review mode that scores an existing project's three layers and names the one that is missing.

The vocabulary for making agent skills predictable — context load, completion criteria, progressive disclosure, and the failure modes that erode them.

Pure reference, not a workflow: what I reach for when writing or editing a skill, to decide what belongs inline, behind a linked file, or in its own skill entirely. It names the failure modes — premature completion, duplication, sediment, sprawl — that diagnose why an existing skill isn't firing the way you expect.

Scaffolds a Godot 4.6 project that boots green on the first headless probe run.

Every fresh Godot project used to cost a day re-discovering the same two traps — a package-manager engine shim that silently breaks headless invocation, and a missing Android compression flag that presents as a wall of blank config errors. This scaffolds the project with the engine pinned, the flag set, and a bounded-kill probe harness, so the game provably boots before any gameplay code exists.

A faceted index over thousands of free game assets and addons — queried by mechanic, art style, theme, and license before I hand-roll anything.

Every asset and tool I've collected gets tagged along ten axes — mechanic, type, art style, theme, genre, license — so “what free thing already does this” is a one-line query instead of a fresh web search each project. It fronts two narrower catalogs, a CC0 art library and a Godot addon adoption log, under one schema.

A catalog of free, commercially-safe Godot addons plus a decision log — adopted, evaluated, or rejected, with the why written down.

Before hand-rolling a Godot system I check whether a vetted free addon already does it, using a local catalog scraped from the public asset library and store. Every decision gets logged — especially rejections, because writing down why an addon was the wrong fit saves the whole re-evaluation on the next project.

A local, indexed CC0 art library — search by theme, copy into any project, attribution logged automatically.

I indexed a large CC0 bundle at pack level with stable item codes, so pulling art for a prototype is a one-line search-and-copy instead of a hunt through thousands of files. Every copy appends its credit line automatically, keeping provenance clean without anyone thinking about it.

A router that picks the cheapest way to get a 3D object into a Godot game — catalog, then generated, then hand-modeled.

Every mesh request runs the same decision: check the free catalog first, fall back to headless parametric generation for simple props, and reserve live interactive modeling for the genuinely bespoke. Whichever tier produces the file, it gets the same finish — landed, import-verified against the real engine binary, credited.

Headless Blender turns shape parameters into a verified, Godot-ready low-poly GLB — no GUI, no clicks.

Generates parametric low-poly props and round-trip verifies that the export actually imports into Godot before it lands in a project with attribution logged. Includes a decimate-and-UV cleanup pass for dense AI-generated meshes and a manifest mode that builds a game's whole prop list in one run.

Tunes game numbers against a measured target — one knob at a time through a headless simulation, never by feel.

Balance is a search problem: name every tunable knob, define the target as a checkable band — a win-rate range over a thousand simulated runs, not “feels fair” — then sweep one variable at a time until the metric lands in band. Only after the simulation confirms the math does a human playtest judge whether balanced is also fun.

Captures and inspects golden-frame screenshots of a running build so a human playtest judges feel, not broken rendering.

Boots the build in a real window — headless renders nothing — captures the key states, and checks each frame against a concrete list: layout, clipping, theme application, text overflow, effect triggers. Mechanical breakage gets caught by the machine before a human ever opens the build; fun stays a human call.

Drafts store copy and the asset checklist across storefronts, gated by a privacy scrub and a trademark-safety check.

Every listing starts with the hook — the one line that earns the download — then per-storefront copy and exact screenshot specs. Two non-negotiable gates run before anything ships: a privacy scrub over copy and screenshots, and a trademark-safety check so marketing never leans on someone else's brand, even implicitly.

A repeatable Google Play compliance audit — rating, ads, IAP, privacy, permissions — run before every submission.

Audits a mobile game repo across seven policy domains — simulated-gambling classification, ad-timing rules, Play Billing wiring, Data Safety, target audience, target API and permissions, store metadata — and writes verdicts plus owner-decision items to a report. It never touches the legal or rating settings itself; those stay human calls.

Keeps an autonomous ticket board honest — every ticket moving or legitimately blocked, silent stalls caught and unstuck.

A verifier classifies every open ticket — moving, queued, blocked, owner-gated, paused, or genuinely stuck — and only stuck earns action, through a fix ladder: operational fixes inline, code fixes delegated, decisions surfaced to the human. Every guardrail in it was earned by a real failure, from zombie heartbeats to two-writer collisions.

The decision gate before an assistant grabs implementation work — should this be a ticket for the autonomous crew instead?

Well-specified, parallelizable, not urgent: delegate to the board. Urgent, interactive, or faster to do than to spec: do it directly. The skill forces that question to be asked instead of silently defaulting, then covers the ticket-creation checklist — real project id, spec-grade body, measurable criteria, verify it landed, stop polling.

Author Godot tickets a small local coding model can actually land — surgical scope, contract in the body, probes as the gate.

Distilled from watching a roughly 30B local coder land single-file tickets on the first try and fail nearly every cross-file integration. One ticket, one script file, the full API contract pasted into the body, integration owner-owned, headless probes red-teamed before they're armed — and when a ticket keeps failing, the spec gets sharpened rather than the code hand-written.

Scaffolds a dashboard panel plugin from a backend endpoint — self-registering, relevance-scored, tested, built.

Each panel is one file that registers itself on import, declares its data needs, and reports its own relevance so an adaptive layout engine sizes it — adding panel forty stays as cheap as adding panel two. The scaffold produces the plugin, the barrel import, a pure-function relevance test, and a build check, and refuses to run against an endpoint that 404s.

Query a knowledge vault as a graph — paths, neighbors, god-nodes — instead of grepping note text.

A read-only structural layer over an entity/edge table extracted from Obsidian-style notes: how is X related to Y, what connects to X, which entities anchor the graph. Every relationship carries a confidence level — extracted, inferred, or ambiguous — and the skill reports that level instead of flattening how sure the system actually is.

Pulls a YouTube video's transcript straight from its caption track — no download, no API key.

Fetches the spoken text, optionally timestamped, from any YouTube URL or video id so an agent can summarize, quote, or search a video without touching the media file. Falls back to yt-dlp auto-captions when the primary caption API is blocked, and treats every transcript as untrusted data, never instructions.

An audio-asset pipeline: one request turns a description into a finished track and drops it where you need it.

Generate music, menu loops, stingers, ambient beds, or best-effort sound effects for any app or game, then have the file land in your project. Built so a build step can ask for a victory sting in one line and get back a path, instead of hand-curating audio.

Extract what your app does, study ten rivals, find the gaps, and hand back a prioritized build plan.

Reads one of your products, maps everything it can do, researches a field of well-reviewed consumer apps and community projects, and surfaces the features you are missing ranked by value. It treats everything it reads off the web as untrusted data, never instructions.

A reusable guardrail for safely feeding untrusted external content to an agent.

When an agent has to read a README, a web page, an issue, a search result, or an uploaded file, this fences that content off as data and never as instructions, runs detection heuristics, and escalates anything that looks like an injection attempt. Other skills call it before they touch third-party text.

Run and drive an Android app with no physical device — boot an emulator, install, and operate the UI over adb.

Spins up an emulator, installs an APK, and drives plus observes the whole interface through adb screencap and input. Captures the non-obvious gotchas — cleartext traffic, host loopback, preference injection, coordinate scaling — so an agent can test a mobile build headlessly.

Build the latest release of every Flutter app in a workspace and install them to a connected phone in one shot.

Discovers the Flutter apps in a projects folder, builds each one's release APK, and installs them to a plugged-in device, regenerating any missing Android host scaffold along the way. The whole personal app shelf goes from source to phone with a single invocation.

A ship-with-privacy pipeline for a content site: edit data, scrub for secrets and PII, verify, deploy.

The workflow this very page shipped through. It edits the site's typed content, runs a mandatory privacy scrub (no secrets, internal addresses, or harvestable personal data; third-party member data blurred), verifies the build, and deploys — so publishing never leaks something it should not.

A router over nine game-design audit skills — one entry point that picks the right lens for any design question.

Every design question hides the real question: which lens do I need? This router maps feel, loop, level, UX, onboarding, difficulty, economy, motivation, and genre onto their own gate skills, each backed by a condensed reference corpus of named frameworks and principles rather than gut feel. It also keeps the boundary clean: design audits check principles; feel stays a human playtest.

A screen-design review checklist: palette, type scale, layout, motion, and a named list of slop patterns to reject.

Producing a design means committing to numbers — hex values, type ratios, layout proportions — not adjectives. Reviewing a design means checking those numbers against a named slop list: gradient text, glass blur as default, hero-metric big-number grids, modals where inline works. A design passes when every section has numbers and the slop checklist is clean.

Audit a game's nested moment/session/meta loops and mastery curve against nine named principles.

A game is a stack of nested loops — moment feeds session feeds meta — and fun is the brain mastering a pattern that keeps teaching something new. The gate checks whether the three loops are nameable, whether new mastery appears past the first hour, whether risk pays off, and whether the next goal is always visible. Structural shape only — whether the loop hooks a real player is a playtest.

Audit a level's spatial pacing — sightlines, breadcrumbing, teaching-through-space, and encounter composition.

A space that is uniform everywhere has no decisions in it. The gate checks whether key POIs have distinct silhouettes, whether the critical path is breadcrumbed by geometry rather than HUD markers, whether tension and release are staged spatially, and whether every enemy gives a cue before the first hit. Based on Valve's HL2 playbook, Dark Souls interconnection, and Totten's spatial analysis.

Audit a game's menus, HUD, and accessibility — gamepad parity, focus handling, colorblind safety, and modal input trapping.

UX runs on four layers that must all hold at once: information architecture, feedback, navigability, and accessibility. A menu can look polished and still fail if a control is unreachable by gamepad, focus drops on rebuild, or state is encoded by color alone. The gate catches the mechanical breakage; whether the result feels intuitive is a human playtest.

Audit a game's first-time-user experience — teaching by doing, one idea at a time, with a cannot-fail opening.

Teaching is affordance, constraint, feedback — delivered by the level, not a text box — stacked into a no-tutorial tutorial where the player induces the rule by doing it. The gate checks whether every core verb has a taught first use, whether mechanics are introduced one at a time, and whether a hook appears in the first fifteen minutes. Based on Valve's Portal method, Celeste, and Norman.

Audit a game's challenge curve — flow channel, DDA, telegraphing, recovery windows, and dominant-strategy prevention.

The flow channel plots challenge against skill — a moving target, so a static curve goes stale. The gate checks whether challenge tracks capability rather than time, whether DDA or player-facing difficulty control exists, whether every threat is telegraphed, and whether no single strategy dominates all others. Based on Csikszentmihalyi's flow theory and soulslike fairness canon.

Audit a game's internal economy — sources, sinks, converters, feedback-loop signs, and scarcity that forces real trade-offs.

A healthy economy is not numbers go up — every pool has both inflow and outflow, loops are deliberately signed, and scarcity forces real trade-offs. The gate checks whether every resource has a named sink, whether converter costs scale with output value, whether unintended positive feedback loops exist, and whether a stopped player still sees economic movement. Based on Adams and Dormans.

Audit a game's retention hooks against Self-Determination Theory — and draw the line at dark patterns.

Durable motivation is intrinsic and grows when a game satisfies competence, autonomy, and relatedness. The gate checks whether mastery feedback is legible, whether strategies offer real tradeoffs, whether rewards are informational rather than controlling, and whether the design crosses the dark-pattern line — no gacha, no energy gates, no streak FOMO, no pay-to-skip. Based on Deci and Ryan's SDT and PENS.

Audit a game against its own genre's player-expectation contract — must-haves, classic pitfalls, and deliberate convention-breaks.

A genre label is a prediction the player makes before they touch a button — it sets expectations for the core verb, loop, failure model, and feedback. Breaking a convention is fine if done knowingly with a compensating re-teach; breaking it accidentally reads as a bug. The gate checks whether genre must-haves are implemented, whether the primary verb feels the way the genre demands, and whether the declared genre pitfall has a demonstrated mitigation.

Audit a game's moment-to-moment tactile quality — responsiveness, juice, hitstop, easing, camera, input grace, and accessibility.

Game feel is real-time control of a body in a simulated space dressed in polish — strip the polish and the game still works but feels dead. The gate checks whether every core verb responds within two to six frames, whether each has visual and audio feedback, whether impacts fire juice, whether heavy hits use hitstop, and whether a reduce-motion option exists and is player-reachable. Based on Swink and Vlambeer's Art of Screenshake.

Wire a game's audio layer — bus layout, music loop and rotation, SFX mapped to every gameplay verb, and options-UI volume hooks.

A silent game reads as a demo no matter how good the mechanics are. The skill maps the audio bus layout, background music with track rotation, and SFX wired to every core verb and juice event — select, hit, death, wave clear, denied action — each triggered at the same call site as its visual feedback. Includes a headless audio probe pattern and CC0 or generated-only sourcing rules.

Drive BlenderMCP interactively to produce bespoke 3D objects — vertex-level precision with live visual verification and GLB export.

When a shape needs human-guided modeling rather than parametric generation, this drives an interactive BlenderMCP session — viewport screenshots after each operation, continuous verification at every step, and a final GLB export with Godot import verification. Handles edge-case geometry that headless parametric scripts cannot express.

Build and port Godot and Flutter games to Steam Deck — native Linux, Proton, Flatpak, and a verification checklist.

Covers four development paths for getting a game onto Steam Deck: native Godot Linux export, Proton compatibility for Windows builds, Flatpak packaging, and Flutter Linux builds. Includes a review rubric that checks input mapping, resolution scaling, suspend/resume, and controller layout — the things that make or break a Deck experience.

Turn any folder of files into a navigable knowledge graph — community detection, audit trail, interactive HTML, and GraphRAG-ready JSON.

Ingests a corpus of files, extracts entities and relationships via progressive context building, assigns confidence levels to every edge, runs Louvain community detection, and outputs both an interactive HTML graph and a GraphRAG-ready JSON. Designed to make a pile of notes, docs, or code into a queryable structure without manual curation.

Generate draw.io diagrams with custom styling, rich shapes, and headless PNG/SVG/PDF export.

Produces draw.io XML with custom styling, swimlanes, and rich shapes, then exports to PNG, SVG, PDF, or JPG via the draw.io CLI in headless mode. Supports Graphviz dot integration for auto-layout, handles the mxGraph XML format, and runs fully headless for CI and automation.

Automate browser interactions and run Playwright tests from the command line — no GUI, no manual clicks.

Drives a Playwright browser headlessly to navigate, fill forms, click, screenshot, and assert — all from the CLI with no manual interaction. Useful for end-to-end testing, browser-driven uploads, and any workflow that needs a real browser but not a human at the keyboard.

Create production-ready Claude Code skills with the right structure — YAML frontmatter, progressive disclosure, and completion criteria.

Scaffolds a Claude Code skill from scratch or refactors an existing one into the canonical structure: YAML frontmatter with name and description, progressive disclosure with the most-used path first, explicit completion criteria, and a self-improvement section. Prevents the common failure modes — premature completion, prompt sediment, scope sprawl, and duplication.

Discover, launch, and drive Pinokio-managed local AI apps — ComfyUI, Fooocus, Stable Diffusion, and any other packaged AI tool.

Controls the Pinokio runtime to discover installed apps, launch them with the right configuration, and drive them via the pterm CLI. Pinokio packages hundreds of local AI tools into one-click installs with isolated Python environments; this skill makes an agent able to use any of them without manual clicking.

Lazy senior dev mode — forces the simplest solution that works: YAGNI, stdlib first, no unrequested abstractions.

A coding stance that runs a decision ladder on every change: does this need to exist, is it already in the codebase, does stdlib do it, does the platform cover it, can it be one line. Stops at the first rung that holds. Not about writing less — about not writing more than the problem asks for. Pairs with sub-skills for auditing, review, debt tracking, and impact measurement.

Repo-wide over-engineering audit — ranked findings across five categories: delete, stdlib, native, YAGNI, and shrink.

Scans a codebase for over-engineering and ranks every finding by category: code that can be deleted outright, stdlib replacements for hand-rolled utilities, native platform features that make a dependency redundant, speculative flexibility nobody asked for, and code that can be shrunk without losing behavior.

Review diffs for over-engineering — one line per finding, focused on what to remove or simplify.

Runs a ponytail-lens review over a diff or set of changed files, outputting one line per finding: the file, the over-engineering, and the simpler alternative. Catches single-caller abstractions, wrapping that adds nothing, speculative parameters, and dependencies that stdlib replaces.

Production Next.js, React, and Prisma apps, end to end — auth, data, admin, and the boring reliability under it.

I build and operate real web platforms, not prototypes: server components, a typed data layer over Postgres, rate-limited public APIs, audit logging, and the admin surface that earns its keep weekly. FreedomGuard and the or9.space platform are the proof.

Design and run a multi-agent swarm that actually ships — gated, verified, and pointed at real artifacts.

I build agent pipelines that decompose a goal into tasks, run specialists in parallel, and gate every result on real tests and visible diffs instead of an agent's word. The hard part is the discipline that keeps the swarm shipping working code rather than looping forever; that is what I bring.

End-to-end test coverage and CI that gate releases at production scale.

My day job: Selenium Grid for parallel cross-browser runs, Jenkins pipelines for PR gates and post-deploy smoke, dashboards and flake detection, and failure routing into chat and on-call. I make releases boring on properties that serve real traffic.

Flutter and Kotlin Multiplatform games and tools for Android, desktop, and niche hardware.

One codebase, many targets: card games and a chess engine on Flutter, a match-three on Kotlin Multiplatform across Android and desktop, even a full roguelike on a 576×288 smart-glasses display. Functional cores that are testable without a device.

Local LLM and diffusion stacks with GPU routing — no cloud bill, no data leaving the building.

I run the model serving, the GPU routing across cards, and the pipelines on top, entirely on local hardware. Image-to-video diffusion behind a bot fleet, a swarm on local models, a private app store on a private network — built for people who want the capability without the cloud.