simiancraft-skills

simiancraft-skills

Claude Code skills for the full arc of a change: farm to table, with receipts.

Curated Claude Code skills and agents from simiancraft. Most skill collections are grab bags. This one has a spine: it carries a change through its whole life. Plan it, structure it, run it and watch it behave, and prove it on the pull request. No stage advances on narrative. Every gate is something you observed: a screenshot that came back from the emulator, a logcat line, a byte count that got smaller, a plan file that deleted itself when the work shipped.

Install

/plugin marketplace add simiancraft/simiancraft-skills
/plugin install simiancraft-skills@simiancraft-skills

Update later:

/plugin marketplace update simiancraft-skills

The arc

Each stage of a change has a home here, and each stage ends in an observable gate:

The seams are contracts with names, not habits. The evidence skill emits artifacts to a documented contract that the proof skill consumes; the GIF capture skill ends at embedding in a PR; the proof skill defers artifact shrinking back to asset-optimization. Farm to table.

What's in here

Plan

• how-to-plan: methodology for tactical, hand-off-ready planning docs. Goal-as-north-star with a 150-word cap, atomic commit steps with verification gates, before/after file trees, and the Inspector Gadget Rule: plans self-destruct when shipped, behind a two-key handshake.

Structure

• zone-composer: React composition pattern for domain features (screens, panels, tools, editors, wizards). A chassis owns data and state branching via flat early returns; presentational leaves take named zones instead of flag props; mutations live in actions/; layouts are polymorphic. Lean core plus six task references.

Drive and observe

Three harness trunks, one mental model: boot the runtime, drive the UI by stable handles rather than brittle coordinates, and gate on what comes back. Each trunk declares a specialization contract; a sibling skill reads the trunk first and adds only its delta.

The camera skills ship a person: a pre-framed human subject fixture fed to the emulator or browser camera, so segmentation models produce a real mask with no physical device in the loop.

Web

• playwright-harness: the operational trunk for browser work. Writes a script, launches Chromium (real GPU under WSLg via ANGLE when WebGL matters), drives the page, and gates on screenshots plus collected page errors. Two references carry the depth: interactions (locators, actions, waits, assertions) and flows (login and session reuse, forms, responsive sweeps, link checking, network stubbing).
• playwright-camera-mask-testing: puts a real person in front of getUserMedia so MediaPipe selfie segmentation produces an actual mask, then verifies background replacement, blur, and shader effects by vision. Ships a webcam-shaped subject fixture and an empty-scene negative case.
• playwright-gif-capture: drives a page, canvas, or WebGL animation deterministically, grabs frames, and encodes a looping GIF, with a reference on the color, frame-rate, and size dials so the output is not deep-fried, janky, or oversized.

Android

• android-emulator-harness: the Android analog of Playwright for web. Boots an AVD headless under KVM on Linux/WSL, installs an APK, drives the UI with Maestro, and gates on logcat plus screenshots that come back for inspection.
• android-emulator-mask-testing: gets a real person in front of the emulator camera so MediaPipe / ML Kit selfie segmentation produces an actual mask, then verifies background replacement, blur, and shader effects. Ships a pre-framed subject fixture.

iOS

• ios-simulator: the iOS analog of the other two trunks. Discovers and boots a device, installs and launches an app, drives the UI by accessibility (AXe), captures screenshots (video capture lives in ios-simulator-flow-evidence), and covers the simulator's own chrome, device state, and execution modes.
• expo-ios-simulator: runs an Expo / React Native app on the simulator; sits on top of ios-simulator. Picks an execution mode (Expo Go, dev client, Storybook-mobile, web-on-mobile), builds and installs a dev client, and clears the recurring Expo prompts that block automation.
• ios-simulator-triage: a living failure catalog organized by layer: build failures, app-runtime vs Expo-runtime failures, and automation failures that emit no error. Each layer names where its logs live.
• ios-simulator-flow-evidence: captures proof of a driven flow: vision-verifiable screenshots, video, and a manifest tying steps to artifacts, plus an honest list of what a simulator cannot do. Owns extraction, not publishing.

Shared trunks

• mobile-accessibility: makes a mobile app driveable and auditable through the accessibility tree, the shared dependency behind every tap-by-label interaction. One tree, two consumers: driving reads the stable handle, auditing reads the user-facing semantics.
• expo-developer-tools: reading the Expo / React Native in-app developer tools: the developer menu, React Native DevTools, and Rozenite plugins. The shared home both platform families point to; an interpretive reference, not a driver.

Shrink

• asset-optimization: shrinks a media asset to the smallest bytes that still serve its purpose, keyed on asset kind (raster, vector, animation, video, audio, model, document, font) and on where it will be presented. Measures before and after, validates the output, and keeps the result only if it is smaller AND still valid; redirects to a better format when the source is wrong for the job.

Prove

• prove-work-on-github: proves that work claimed on a pull request or issue actually landed and is sound, with verifiable evidence a reader can independently re-check. Sizes the proof a change owes, names what must be proven, supplies the receipts, stores them durably in an evidence branch rendered inline on the PR, and judges whether they are enough to merge.

Burn down

• burn-down-github-issues: runs the whole arc unattended over an issue backlog. Appraises and sizes recent issues, closes stale ones with re-checkable receipts, fixes small ones in parallel git worktrees, proves each fix per prove-work-on-github on a draft PR, has an isolated second-engine reviewer judge it against the proof skill's rubric, and merges one branch at a time with import-closure staleness checks. The loop ships with the skill; a repository carries only a config file, and the loop refuses to start without it.

• appraise-github-issues: sizes a backlog and closes what is done, without fixing anything. One read-only agent turn per issue decides whether it is still real and how big it is; the answer lands on the issue as a size: N label, a needs-decision or needs-human label with the question stated, or a close with a re-checkable receipt that a confirmer on a second engine has independently re-checked. Runs on one issue, a window, the whole backlog, or as a periodic heartbeat, and is the sizing stage of the burndown.

• fix-github-issue: turns one known issue into a merged pull request. A coder changes and pushes it in its own git worktree, and a prover on a fresh context opens the pull request carrying proof per prove-work-on-github; an isolated second-engine reviewer judges that proof; a serial pull master checks the approval against import-closure staleness and the pull request's own checks before it merges, and parks rather than guesses. Runs standalone from its fix.ts, or as the fix stage of another loop, which is what the burndown does with it.

• code-github-issue: the Coding lane. One headless turn makes the smallest change for a sized issue, runs the repository's gate, commits, and pushes, then stops; its answer is believed only when the remote holds the commit it names, and the driver announces that push on the issue so any later run can pick the work up from it.