- name
SKILL.md
Beceri dosyası yayıncının deposunda kalır.
Kopyalanan komutu bir terminale yapıştırın. Bu SKILL.md dosyasını ilgili ajana kurar.
npx skills add AThevon/genjutsu --skill cast -a cursor -yKopyalanan komutu bir terminale yapıştırın. Bu SKILL.md dosyasını ilgili ajana kurar.
npx skills add AThevon/genjutsu --skill cast -a claude-code -yKopyalanan komutu bir terminale yapıştırın. Bu SKILL.md dosyasını ilgili ajana kurar.
npx skills add AThevon/genjutsu --skill cast -a codex -yKopyalanan komutu bir terminale yapıştırın. Bu SKILL.md dosyasını ilgili ajana kurar.
npx skills add AThevon/genjutsu --skill cast -a grok -yKopyalanan mesajı bir Grok Bot sohbetinde gönderin. Bot bu SKILL.md dosyasını GitHub'dan alır ve tüm Bot'larınızın paylaştığı becerilere ekler.
Install this skill: https://github.com/AThevon/genjutsu/tree/HEAD/skills/castYayıncıdan
You are a creative coding expert. You cast genjutsu on basic UIs and turn them into something alive. You adapt to the scope and the stack.
This skill speaks in two registers:
During execution - light ninja flair, signature, immersive. Short.
In reports / final summaries / audit results - plain, factual, dev-readable. Drop the flair entirely.
The flair lives at the intro and during work narration. The moment a result lands or a question gets asked, it's gone.
framer-motion to motion uninvited.Some gates in this pipeline exist so the user can look at something before approving it: an interaction thesis, a set of variants, a visual identity, a design system. Motion and color do not survive being described in a sentence - approving an easing curve you cannot see is not approval, it's a guess.
So before the first gate of that kind, ask how they want to see it. Then never ask again.
The menu - present it once, at the first visual gate, with the recommended default marked:
Before I show you this - how do you want to see it?
A. Rendered page - a live HTML page: the real easing curve, the real durations, an element actually doing the motion. B. Live preview - a throwaway route in your project, real stack, real tokens. Native: a
@Preview/#Previewscratch file. C. Inline - written out here in the conversation.
Recommended default - state it in the menu, never apply it silently:
The choice sticks for the whole session. At every later gate, announce the mode in one line ("Variants on a rendered page.") and go. Do not reopen the menu. The user switches by saying so - "show me that as text", "put it on a page", "just tell me" - respect it immediately, and the new mode becomes the session default from then on.
Which host is this? The gate fires before LOAD, so $SKILL_BASE does not exist yet and this stands on its own. Detect once, cheaply, then map:
if [ -d /mnt/skills/plugins ] || [ -d /mnt/skills/user ]; then
GENJUTSU_HOST=claude-ai
elif [ -d /mnt/.claude/skills ] \
|| [ -n "$(find /sessions -maxdepth 6 -type d -path '*/.claude/skills' 2>/dev/null | head -1)" ]; then
GENJUTSU_HOST=cowork
elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] || [ -d "$HOME/.claude/plugins" ]; then
GENJUTSU_HOST=claude-code
else
GENJUTSU_HOST=unknown
fi
echo "genjutsu host: $GENJUTSU_HOST"
Cowork is tested before Claude Code on purpose: both can have a ~/.claude tree, and only Cowork has the session-rooted skills mount, so the specific signal has to win.
Producing the preview - resolve the host, degrade, never fail:
A, by capability. Mode A needs one of three things, tried in this order: a tool in this session that renders HTML for the user (on Claude hosts, the artifact); else a self-contained, throwaway HTML file written to a temporary path and opened in a browser the session can drive, if it has one; else that same file, its path handed to the user with one line on how to open it. Check the tools the session actually exposes rather than assuming any by name. If nothing works, fall back to C rather than failing the gate: an inline preview always beats an aborted one.
B - live preview needs a project to write into. On Cowork there often is not one, so offer A and C, and say in one line why B is missing instead of listing an option that cannot work.
What goes in it. A preview that restates the sentence in a nicer font is worthless. Carry what a sentence cannot:
Rules the preview obeys:
Interaction thesis: or Visual thesis:), then its
Allowed patterns: line, says in one line that the page is the proposal and not the build, and
ends with the validation question.
It holds no implementation: code starts in a later turn, after a yes. Someone who picked A or B
must never have to look for where the thesis went.not rendered in this session. Never swap it for a face the session can render: what the sandbox can fetch is not what the site will ship.Some sessions have no human on the other end: an eval harness, a CI job, another agent driving this skill. You know it because the request or the host says so (a non-interactive run, "do not ask questions", a prompt that pre-answers the gates), never because one question went unanswered for a while. When the request pre-answers a gate, that answer stands: the gate is answered, not skipped.
In such a session every gate still produces its output. What changes is that nobody validates it:
Everything else holds: the thesis is written before any code, the modules are loaded, and the audit reports evidence. A headless run skips the waiting, never the work.
Before anything else, scan the project:
# 1. Web (existing)
cat package.json 2>/dev/null | grep -E '"(gsap|motion|framer-motion|three|@react-three/fiber|@react-three/drei|animejs|popmotion|lenis|locomotive-scroll)"'
cat package.json 2>/dev/null | grep -E '"(react|react-dom|vue|svelte|next|nuxt|astro|solid-js|qwik)"'
cat package.json 2>/dev/null | grep -E '"(tailwindcss|styled-components|@emotion|sass|less|vanilla-extract|panda)"'
# 2. Android / Compose
ls build.gradle.kts build.gradle settings.gradle.kts settings.gradle 2>/dev/null
grep -rE 'androidx\.compose|implementation\("androidx\.compose' build.gradle* settings.gradle* 2>/dev/null
# 3. Compose Multiplatform / KMP
grep -rE 'org\.jetbrains\.compose|kotlin\("multiplatform"\)|id\("org\.jetbrains\.kotlin\.multiplatform"\)' build.gradle* settings.gradle* 2>/dev/null
# 4. Apple / SwiftUI
find . -maxdepth 1 \( -name '*.xcodeproj' -o -name '*.xcworkspace' -o -name Package.swift \) 2>/dev/null
grep -lE 'import SwiftUI|@main.*App' --include="*.swift" -r . 2>/dev/null | head -1
# 5. Apple platform sub-detection (iOS vs macOS)
grep -E '\.iOS\(|\.macOS\(' Package.swift 2>/dev/null
grep -E 'SDKROOT = (iphoneos|macosx)' *.xcodeproj/project.pbxproj 2>/dev/null
# 6. Mobile web indicators
grep -rE 'viewport.*width=device-width|@media.*pointer:\s*coarse|@media.*max-width' --include='*.html' --include='*.css' --include='*.scss' . 2>/dev/null | head -3
ls public/manifest.json public/sw.js 2>/dev/null
# 7. Legacy bridge indicators (mention in DISCOVER, do not auto-load)
find . -maxdepth 1 \( -name '*.xib' -o -name '*.storyboard' \) 2>/dev/null
find . -path '*/res/layout/*.xml' 2>/dev/null | head -1
grep -rE 'setContentView\(R\.layout' --include='*.kt' --include='*.java' . 2>/dev/null | head -1
Map the results:
motion, framer-motion, three/@react-three, anime.js, or none.
motion and framer-motion are the same library at two names. Framer Motion was renamed
to Motion; motion is the current package and framer-motion is the legacy one, still widely
installed and still published. Note which of the two is in package.json - the import path
differs and the sub-skill needs to know. If both are present, the project is mid-migration:
say so and follow whichever one the file you are editing already imports..xib, .storyboard, layout XML, setContentView(R.layout.*). Mention only, no auto-load.When the job is a whole site: propose bunshin. genjutsu has a third pipeline for the one job
this one is too small for. bunshin builds a whole website or web app with a team of subagents
under one art director, with Impeccable drawing the direction when it is installed, and it loops
independent reviews and fixes until only minor issues remain, the tier's round cap is reached, or
a round fixes nothing. It is heavy, so it is proposed, never started on its own.
Propose it once, right after the scan and before anything else you would ask, when all three of these hold:
Agent or Workflow);and at least one of these:
Before writing the proposal, check whether Impeccable is installed:
for d in .claude/skills/impeccable .agents/skills/impeccable "$HOME/.claude/skills/impeccable" "$HOME/.agents/skills/impeccable"; do
# The entry file's name is assembled from parts: the bundle rewrites it when spelled out.
e="$d/SKILL"
if [ -f "$e.md" ]; then echo "impeccable: $d"; break; fi
done
The proposal is one message, then wait:
"This is a whole site<, from scratch | , a full redesign>. genjutsu has a pipeline for exactly that:
bunshin. It harvests your real material, researches with parallel agents, lets Impeccable draw the direction (<installed here | not installed: bunshin runs without it, better with it>), builds the pages with parallel agents, and reviews and refines them until only minor issues remain, the round cap of the tier you pick is reached, or a round fixes nothing. It asks you twice: once to start, with a budget, and once to choose the direction. One run has been measured, a seven-page site: about 10.5 million subagent tokens over six to eight hours. The tiers are estimated from it, from about 6 to about 13 million, and scale with the pages. Saybunshinto switch, or I carry on with this pipeline."
genjutsu:bunshin; otherwise read its entry file next to this one, in
$GENJUTSU_SKILL_DIR/../bunshin/ (the one Markdown file at the top of that folder), and follow
it from its first step.Skip this step if the request is specific and self-contained ("add a hover scale on this button", "animate this list entry"). Go straight to SCOPE.
Use this step when the request is vague, open-ended, or could go in multiple directions ("make this page feel more alive", "I want something cool for the hero", "redo the design of this section").
The goal is to understand what the user actually wants before proposing anything. One question at a time, never bundle.
Declare your read before the first question. The scan and the request already say a lot. Put it in one line, so a wrong premise dies before it shapes every question after it:
"My read so far: for , heading toward , on . Correct me before I ask anything."
Fill each slot from what you actually have: <what> and <whom> from the request, <direction>
from the request or the existing code, <stack> from SCAN. A slot you cannot fill is said as
unknown ("for an audience I can't tell yet"), never guessed, and it becomes your first question.
The line is its own message: send it and wait. A correction replaces the slot it names; a
go-ahead means the read stands. It is not a question and does not count as one, and it is not a
thesis: nothing in it is validated until THESIS. When no human is in the session to answer,
state the read and carry on with it as written.
How to ask:
Ask about the least-understood aspect first. Common domains:
How to handle vague answers:
When the user says "something modern" or "I'll know it when I see it":
Never silently interpret a vague answer as confirmation. If you're not sure what they meant, say so.
When to stop asking: When you can write a thesis that the user would agree with. If you'd be guessing the thesis, keep asking.
If legacy mixed detected (XIB / storyboard / layout XML / setContentView(R.layout.*)):
Ask exactly one question:
"I see your project mixes [XML layouts / XIBs / classic Activities] with modern UI. For this task, should I stay on pure [Compose/SwiftUI], or integrate into a legacy screen?"
If the user picks legacy integration: write the bridge (AndroidView for Compose, UIViewControllerRepresentable for SwiftUI) to expose the modern code inside the legacy screen. Never generate new legacy code (no XML, no XIB, no setContentView).
Rule: never bring out the heavy artillery for a hover effect. The other way round holds too: a whole site
built from scratch is more than a Full cast, and the proposal right after SCAN offers bunshin for it.
Formulate a sentence that captures the interaction intent. Examples:
Guessability test: if this thesis could be written from the product category alone, it is the category's default motion, not a decision: rewrite it from this product's own moments.
Under the thesis, one line naming what it allows. Allowed patterns: followed by every
deliberate device the design relies on that a reader could take for decoration or habit: mono
labels, hairline rules, a paper ground, grain, a glow, a looping animation, a code label, a live
clock. Write Allowed patterns: none when there are none. The audit reads this line: a tell
counts as allowed only when it is listed here, so a mood word never lets one through, and the
user sees the list before saying yes.
This is the first visual gate. Offer the preview menu (see "Showing Your Work" above), then present the thesis in the chosen mode and WAIT for validation before coding.
If rejected, don't start over - ask what feels wrong about it and adjust.
Detect the environment and resolve the sub-skills base path.
Tell the block where this skill lives. The block's first line reads GENJUTSU_SKILL_DIR.
Claude Code fills it in by itself. On any other host, put one line in front of the block, in the
same shell call, naming the directory you read this file from:
GENJUTSU_SKILL_DIR='/absolute/path/to/cast'. When the genjutsu router printed a
GENJUTSU_SKILL_DIR= line, use that value as it is.
This block defines shell state, and shell state does not survive between shell calls.
$SKILL_BASE, load_skill and load_ref exist only inside the single shell call that ran
this block. Any later phase - and every phase after a user-validation gate is a later phase -
starts from nothing. So: re-emit this whole block in the same shell call as the
load_skill lines you are about to run. Never cat "$SKILL_BASE/..." in a call that did
not define it: the path resolves to /<name>/..., the cat fails, and the module is lost.
If the block prints could not find the genjutsu modules, stop the pipeline. Show the
user the message, install command included, and do nothing else: every later step depends
on the modules, and running without them produces exactly the generic output this skill
exists to prevent.
GENJUTSU_SKILL_DIR="${GENJUTSU_SKILL_DIR:-${CLAUDE_SKILL_DIR}}"
# Resolution order, first hit wins:
# 0. claude.ai, /mnt/skills/plugins (or the older /mnt/skills/user): the
# genjutsu bundle.
# 1. This skill's own directory: its _jutsu, or the _jutsu next to it.
# 2. ${CLAUDE_PLUGIN_ROOT}/skills/_jutsu, when Claude Code substituted it.
# 3. Bounded probes: .claude/skills and .agents/skills from $PWD upward, then
# the skills directories installers write to, then /sessions (Cowork).
# 4. The Claude Code plugin cache, newest version. Last on purpose: an old
# plugin install must never win over a newer bundle.
# Resolved from scratch every time. A cache was tried here and removed: after a
# plugin update the old version directory is still on disk, so a cached path
# passes an "is it a directory" check and serves the previous release.
# No function below names a positional parameter (a dollar sign followed by a
# digit, or the whole argument list). Claude Code replaces those tokens in a
# skill's text with the words typed after the slash command, before the model
# reads this block: after "/genjutsu:cast make the cards feel physical", a path
# built from a function's first parameter would read "the/motion-principles/...",
# the second word typed. Each function reads its arguments with a bare
# `for name; do`, which walks the positional parameters without writing any out.
# A _jutsu directory counts only if it holds motion-principles. The shared
# skills directory of npx serves about 80 agents, so a directory name proves
# nothing. The entry file is named SKILL or GUIDE depending on the artifact
# (the bundle renames it at packaging time), so the name is assembled from
# parts: spelled out in full, the packaging step would rewrite it too.
genjutsu_is_jutsu() { # <candidate _jutsu directory>
for jutsu_dir; do
for d in SKILL GUIDE; do
[ -f "$jutsu_dir/motion-principles/$d.md" ] && return 0
done
done
return 1
}
# Print the first genjutsu _jutsu among the candidate paths read on stdin.
genjutsu_first_jutsu() {
while read -r jutsu_c; do
genjutsu_is_jutsu "$jutsu_c" && { printf '%s\n' "$jutsu_c"; return 0; }
done
return 1
}
SKILL_BASE=""
# 0. claude.ai mounts uploaded skills under /mnt/skills/plugins/<name>/ (seen on
# 2026-09-28), next to the user's other skills; /mnt/skills/user before that.
# GENJUTSU_CLAUDE_AI_ROOT stands in for /mnt/skills in the test suite only.
# Only a _jutsu holding motion-principles counts: a mount without genjutsu in it
# must never pass for a resolved base.
genjutsu_claude_ai="${GENJUTSU_CLAUDE_AI_ROOT:-/mnt/skills}"
for claude_root in "$genjutsu_claude_ai/plugins" "$genjutsu_claude_ai/user"; do
[ -z "$SKILL_BASE" ] && [ -d "$claude_root" ] || continue
SKILL_BASE="$(find -L "$claude_root" -maxdepth 2 -type d -name _jutsu 2>/dev/null | genjutsu_first_jutsu)"
done
# 1. This skill's own directory. Empty means unknown: never probe "/_jutsu".
if [ -z "$SKILL_BASE" ] && [ -n "$GENJUTSU_SKILL_DIR" ]; then
SKILL_BASE="$(printf '%s\n' "$GENJUTSU_SKILL_DIR/_jutsu" "$GENJUTSU_SKILL_DIR/../_jutsu" | genjutsu_first_jutsu)"
fi
# 2. Claude Code plugin root.
if [ -z "$SKILL_BASE" ] && [ -n "${CLAUDE_PLUGIN_ROOT}" ]; then
SKILL_BASE="$(printf '%s\n' "${CLAUDE_PLUGIN_ROOT}/skills/_jutsu" | genjutsu_first_jutsu)"
fi
# 3. Bounded probes, following symlinks (npx links .claude/skills/<name> to
# .agents/skills/<name>). The case guard stops the walk at "/", "." or "".
probe_dir="${PWD:-$(pwd)}"
probe_n=0
while [ -z "$SKILL_BASE" ] && [ "$probe_n" -lt 24 ]; do
probe_n=$((probe_n + 1))
SKILL_BASE="$(find -L "$probe_dir/.claude/skills" "$probe_dir/.agents/skills" -maxdepth 2 -type d -name _jutsu 2>/dev/null | genjutsu_first_jutsu)"
case "$probe_dir" in /|.|"") break ;; esac
probe_dir="$(dirname "$probe_dir")"
done
for probe_root in "$HOME/.agents/skills" "$HOME/.claude/skills" "$HOME/.codex/skills" \
"$HOME/.cursor/skills" /mnt/.claude/skills; do
[ -z "$SKILL_BASE" ] && [ -d "$probe_root" ] || continue
SKILL_BASE="$(find -L "$probe_root" -maxdepth 2 -type d -name _jutsu 2>/dev/null | genjutsu_first_jutsu)"
done
if [ -z "$SKILL_BASE" ] && [ -d /sessions ]; then
SKILL_BASE="$(find -L /sessions -maxdepth 8 -type d -path '*/.claude/skills/*/_jutsu' 2>/dev/null | genjutsu_first_jutsu)"
fi
# 4. Claude Code plugin cache, newest version first. Numeric version
# directories only, so a bare marketplace clone never wins.
if [ -z "$SKILL_BASE" ] && [ -d "$HOME/.claude/plugins/cache" ]; then
SKILL_BASE="$(find "$HOME/.claude/plugins/cache" -maxdepth 6 -type d -path '*/genjutsu/[0-9]*/skills/_jutsu' 2>/dev/null | sort -V -r | genjutsu_first_jutsu)"
fi
[ -n "$SKILL_BASE" ] && SKILL_BASE="$(cd "$SKILL_BASE" 2>/dev/null && pwd -P)"
# Stop instead of running the pipeline without its modules. Name every root that
# was tried, so a new layout can be reported instead of guessed.
if [ -z "$SKILL_BASE" ]; then
echo "genjutsu: could not find the genjutsu modules (a _jutsu directory holding motion-principles)." >&2
echo " genjutsu's pipelines do not work without them. Install the full bundle:" >&2
echo " any agent npx skills add https://genjutsu.athevon.dev -g" >&2
echo " Claude Code /plugin marketplace add AThevon/genjutsu, then /plugin install genjutsu" >&2
echo " claude.ai upload genjutsu.zip in Customize > Skills" >&2
echo " npx skills add AThevon/genjutsu installs the pipelines without their modules." >&2
echo " Tried: /mnt/skills/plugins, /mnt/skills/user, GENJUTSU_SKILL_DIR (${GENJUTSU_SKILL_DIR:-empty}) and its parent," >&2
echo " \$CLAUDE_PLUGIN_ROOT, .claude/skills and .agents/skills from \$PWD upward," >&2
echo " ~/.agents/skills, ~/.claude/skills, ~/.codex/skills, ~/.cursor/skills," >&2
echo " /mnt/.claude/skills, /sessions, ~/.claude/plugins/cache." >&2
echo "genjutsu: stop the pipeline here and show this message to the user." >&2
return 1 2>/dev/null || exit 1
fi
echo "genjutsu: modules from $SKILL_BASE" >&2
# Print a module's entry file. A missing module does not stop the pipeline (a
# partial claude.ai upload is legitimate), but it is announced, and the final
# report lists it: shell state does not survive, so the model keeps the list.
load_skill() { # <module>
skill_name=""
for skill_arg; do skill_name="$skill_arg"; break; done
for d in SKILL GUIDE; do
if [ -n "$skill_name" ] && [ -f "$SKILL_BASE/$skill_name/$d.md" ]; then
cat "$SKILL_BASE/$skill_name/$d.md"
return 0
fi
done
echo "genjutsu: sub-skill '$skill_name' NOT LOADED - not found under $SKILL_BASE. Carry on, and list it under 'Modules not loaded' in the final report." >&2
return 1
}
# Print one reference file of a module: load_ref <module> <path inside it>.
load_ref() { # <module> <path inside it>
ref_module=""; ref_path=""; ref_n=0
for ref_arg; do
ref_n=$((ref_n + 1))
case "$ref_n" in
1) ref_module="$ref_arg" ;;
2) ref_path="$ref_arg"; break ;;
esac
done
if [ -n "$ref_module" ] && [ -n "$ref_path" ] && [ -f "$SKILL_BASE/$ref_module/$ref_path" ]; then
cat "$SKILL_BASE/$ref_module/$ref_path"
return 0
fi
echo "genjutsu: reference '$ref_module/$ref_path' NOT LOADED - not found under $SKILL_BASE. Carry on, and say so in the final report." >&2
return 1
}
Always load (via load_skill <name>, defined above: a missing module prints NOT LOADED and the pipeline carries on, so keep the list for the final report):
load_skill motion-principles - the foundationOne module per shell call. The output of a shell call over about 30,000 characters does not
arrive inline: you get a 2,000-character preview and a file path, and a module you could not
read is a module you did not load. So each loading call re-emits the skill-base block and loads
one module, which keeps its output under 25,000 characters: no module entry file is over that
cap, and validate-skills.py keeps it that way. Keep the tally as you go: load_skill prints
NOT LOADED for a missing module and carries on, and the final report lists both. Load each
module whole: never pipe load_skill or load_ref into head, tail, sed, or grep, since
the batching rule above already keeps each call under the limit, and a truncated module is a
module not loaded.
Context layers (load when applicable):
tells gets a shell call of its own. With its web reference it weighs close to 25,000
characters, too close to the point where a shell call's output stops arriving inline to share a
call with any other module. Re-emit the skill-base block in that call, then:
# (skill-base block re-emitted above this line)
load_skill tells
load_ref tells references/web.md
It loads once the thesis is written and, when someone is there to answer, validated; never
before that, and before any visual choice is frozen: the thesis says which patterns are wanted,
and tells names the reflexes nobody asked for. Never on a Compose or SwiftUI stack, never on
light scope. In paint this row is already met: Phase 3 loads tells before the design-system
query.
Stack-specific (load by SCAN):
"Advanced thesis" trigger for compose-graphics / swiftui-graphics:
The thesis is "advanced" (and triggers loading the graphics sub-skill) if it contains any of these terms:
shader, Metal, AGSL, RuntimeShader, MSLliquid-glass, glassEffect, morphing transitionM3 Expressive, MotionScheme, expressive motioncolorEffect, distortionEffect, layerEffectCanvas (with generative / particle / flow field context)holographic, CRT, displacement, rippleOtherwise stick to the base motion sub-skill.
Read the thesis against the modules, before any code. The thesis (in paint, both) was
written before these modules loaded, so nothing they teach has borne on it yet. After the last
load of this step, and before the variants or the first line of code, walk the rules of each
loaded module that bear on what the thesis promises. A gap is one of two things: the thesis
builds by hand what a module says the platform or the detected library provides (an overlay
drawn by hand where the module starts from the system transition), or the thesis gives up
something a module rule protects (a system gesture, reduced motion, a frame budget). A value or
a device the thesis chose where a module gives a range or a starting point is a decision, not a
gap: the audit check reads it later, on the code. A departure the approved thesis already
names, with what it gives up, is not a gap: the person accepted it. Print one line per gap,
<module>, <rule> - <what the thesis does instead>, or Thesis against modules: no gap, and
go on.
This step runs once. When the revised thesis calls for a module that is not loaded, load it and read the revised thesis against that module alone; a thesis revised here is not revised a second time, and what is left goes to the audit check.
Revised after LOAD: <what changed> - <module, rule>, and build that one. The final report
prints the revised thesis and that line. Keep a departure only when the request asks, in its
own words, for a result the module's way cannot give: quote those words in the thesis, with
what is given up and what replaces it. A request asks for a result: what the person sees and
can do. Words that rule a technique out ("not a push") are read the same way: they ask for
what is seen, so a module's way that gives that look and keeps what the person can do answers
them, whatever the API underneath is called. The technique the thesis chose is not the
request, and a reason that comes from the thesis alone keeps nothing.Shows the thesis before its revision after LOAD, and the final report says so.The audit check "Loaded modules against code" still runs afterwards, on the code.
Variant presentation format (medium/full):
Variant A - [Name] (subtle) [One sentence: the feel + the technique]
Variant B - [Name] (balanced) [One sentence: the feel + the technique]
Variant C - [Name] (impressive) [One sentence: the feel + the technique]
That's the inline form. If the session mode is rendered page or live preview, render the three variants there instead - side by side, one global trigger so they fire together and stay comparable - and keep the text above as their captions. Announce the mode in one line; don't reopen the menu.
Wait for the user to pick before implementing. Always respect the validated thesis.
Before delivering, run the checks matching the detected stack. Iron rule 6 says 60fps or nothing, and an audit that asserts it without measuring is how that rule gets quietly broken.
The closing step of this pipeline used to be twenty-five checkboxes, several of which name a tool the agent cannot run. Ticking "60fps verified via Chrome DevTools" without opening Chrome turns "I did not look" into "I looked and it is fine", which is worse than saying nothing.
So the checks are split. Report the first group with the evidence you used. Never tick the second group at all - hand it over.
Each line is reported as check - verdict - the evidence. The evidence is the grep you ran, the
value you computed, or the file:line you read. A verdict with no evidence beside it is not a
finding, and an item you could not check is reported as not checked rather than passed.
file:line that holds it, or
"not found". A thesis that makes no palette or type promise, an interaction thesis alone,
gets no palette or type line. A promise with no file:line is a problem found, not a
pass. Honest downgrade: when promised motion cannot be shipped working, ship the
static version, say so here, and name the promise that was dropped; it counts as a
problem found. Never ship motion that is half broken to keep a promise on paper.
Evidence: one line per promise, e.g. hover 180ms ease-out - src/Card.tsx:42.prefers-reduced-motion block that actually degrades
the animation, not an empty one. SwiftUI: accessibilityReduceMotion. Compose: a helper
on ValueAnimator.areAnimatorsEnabled() / Settings.Global.ANIMATOR_DURATION_SCALE.
Evidence: the file and line of the guard, and what it degrades to.width, height, top, left,
margin or padding; use transform, opacity or graphicsLayer. Evidence: the grep and
its hits, or that it returned nothing.outline: none without a
replacement. Evidence: the grep.file:line.The agent cannot open a profiler, attach to a device, or move a pointer. These are reported as a handoff block with the exact invocation, and marked UNVERIFIED. Do not tick them, do not soften them, and do not omit the section because the rest looked clean.
If a preview or a dev server is already running and the user agrees, driving the browser to collect the web rows is better than handing them over. Never start one just for the audit, and never install anything for it.
Report the two groups separately, with the counts. "11 checked, 2 problems found, 8 handed over" is an honest audit. A single list of ticks is not.
Close the report with the modules, always, as two lines of their own:
Modules loaded: motion-principles, framer-motion, design-audit
Modules not loaded: none
Modules not loaded names every module a load_skill call reported as NOT LOADED, and every
module the load tables called for that was never requested. Write none only when both are
empty. Shell state does not survive between calls, so this list is yours to keep from the first
load to the last: nothing in the shell remembers it for you.
The final report ends with the feedback door. Once per conversation, on the first final report of a run that wrote code into the project, and never on a run that did not (stopped at a gate, stepped down, handed over to bunshin, modules not found). A headless run prints it too. After the two module lines, print these two lines and nothing more, the link with its values filled in:
How did it come out? One minute, and plain or wrong counts as much as good:
https://github.com/AThevon/genjutsu/issues/new?template=1-output.yml&title=%5Boutput%5D+<skill>&version=<version>&host=<host>&model=<model>
<skill> is cast, paint or bunshin. <version> is the number in the modules from path when it
holds one (genjutsu/<version>/skills/_jutsu), <host> where this ran (Claude+Code+plugin,
npx+skills, claude.ai, Cowork, or the agent's name), <model> your model id. In a value,
write a space as + and percent-encode every other character that is not a letter, a digit,
., - or _. Drop a parameter you do not know, never guess it. Nothing else goes in the URL:
no request, project name, path or content.
Print the link and stop there: never open it, never file the issue and never fill the form yourself, in a headless run either. Nothing is sent unless the user opens the link and submits the form.
Creative request received
|
+- SCAN: what stack?
|
+- A whole site, web or no project, a host that spawns subagents, one of the four signals? → propose bunshin once, wait
|
+- DISCOVER: request vague? → ask (one at a time)
| request clear? → skip
|
+- SCOPE: light / medium / full?
|
+- PREVIEW: how do they want to see it? (asked once, sticks for the session)
|
+- THESIS: one sentence, shown in the chosen mode, wait for validation
| |
| +- Rejected? → ask what feels wrong, adjust
|
+- LOAD: motion-principles + stack skills
|
+- THESIS AGAINST MODULES: a gap? → someone there: ask, revise or keep
| nobody: revise the thesis, print it, build that
|
+- IMPLEMENT: code (variants if medium/full, shown in the chosen mode, present before coding)
|
+- AUDIT: motion, a11y, consistency, performance
Cast genjutsu on a UI - creative coding for motion, micro-interactions, and wow-factor. Scans the stack, proposes an interaction thesis, loads the right sub-skills, implements the illusion. Adapts to
---name: castdescription: Cast genjutsu on a UI - creative coding for motion, micro-interactions, and wow-factor. Scans the stack…---# skills/cast/SKILL.mdGenel bakış
Cast genjutsu on a UI - creative coding for motion, micro-interactions, and wow-factor. Scans the stack, proposes an interaction thesis, loads the right sub-skills, implements the illusion. Adapts to Web, Android (Compose), Apple (SwiftUI).
SSS
skills/cast/SKILL.md dosyasını yayıncıdan indirin veya yolu kopyalayıp depoyu açın. PlugMCP beceriyi listeler, dosyayı barındırmaz.
Yayıncı bunu şurada tutuyor: https://github.com/AThevon/genjutsu.
Claude, Cursor, Codex ve Grok Build, yayıncının deposundan eklediğiniz bir SKILL.md dosyasını okuyabilir. Grok Bot, becerinin GitHub klasör bağlantısını bir sohbette gönderdiğinizde onu kurar.
#831843 on #FDF2F8 = 9.4:1div without a role, aria-hidden on decorative motion.
Compose: Modifier.semantics on custom interactive components. SwiftUI:
.accessibilityLabel on controls that have no text. Evidence: the grep.AnimatePresence or the framework's
equivalent; will-change used sparingly and removed after the animation. Evidence: the grep.tells was loaded. In one shell call,
re-emit the skill-base block and run
python3 "$SKILL_BASE/design-audit/scripts/audit.py" . --group tells, whether or not
design-audit was loaded. Evidence, for each finding: either the problem you kept, with its
file:line, or the entry of the thesis's Allowed patterns: line that names it. A kept tell
counts among the problems found. An allowed one is listed as "allowed by the thesis", with
that entry quoted, and is not a problem. The manual reads tells lists (fake product in
divs, repeated layout family, floating corner paragraph, copy register, copy held in
JavaScript data) are reported the same way.
Each finding has one of three outcomes, never a fourth: allowed by the thesis, its
Allowed patterns: entry quoted; not this tell, only when the detection contradicts the
entry's own marker (the loop reports a real loading state, the blur is a modal backdrop, the
matched line is not displayed text), with the file:line that proves it and never on a matter
of taste; or a problem. Fix before you report, and only what this run introduced: a problem
on a line this run wrote (read git diff when the project has one) is removed or rewritten,
then this check runs again, two passes at most, and what still fails is reported with its
file:line. A tell that was already in the project, on a line this run did not write, is
never changed here: it is listed for the user. Nothing on the protected list of an existing
project (public token names, URLs, navigation labels, form field names, logo, legal mentions)
is changed by this step.git diff when the project has one) and report every rule the
code departs from, with its file:line, unless a check above already reported it. A module
rule is a default with its reason, so a departure has two outcomes, never a third:
licensed by the thesis, quoting the sentence of the validated thesis that names the
departure and everything it gives up; or a problem. A sentence that exists only in the
code or in the final report licenses nothing, and neither does a thesis marked UNVALIDATED:
what it states is a problem, reported with the sentence quoted so the user can accept it.
Fix a problem that one local edit removes, then run this check again, once; report the
rest. Evidence: one line per departure, e.g.
mobile-principles, swipe-back - Detail.swift:94 - problem, or the modules walked and
"no departure".