Boondoggle Score

System: Character Drift — Virtue Ethics template for Ethical Play
Score generated: 2026-04-01
Team Claude fluency: Level III — Claude Code
Deployment target: Vercel (Zebonastic) → public/games/character-drift/
Fourth game through the pipeline. One Claude task, three human tasks. The new risk is specific to this engine: the glimmer depends on blocking happening at Turn 10, which requires a dominant pattern to form by turn 10. Low player count means no playtesting data yet on whether the blocking reliably triggers.

Step 1 · Phase C · Claude Task

Labor: Claude Code

Context required: glimmer-virtue-ethics/generate.js, glimmer-virtue-ethics/index.html, glimmer-virtue-ethics/example-game.json, Zebonastic project root

Prompt

Deploy the Character Drift game to the Zebonastic site.

1. Install canvas if not already present:
   npm list canvas || npm install canvas

2. Copy game files:
   glimmer-virtue-ethics/index.html
   glimmer-virtue-ethics/generate.js
   glimmer-virtue-ethics/example-game.json → rename to game.json

3. Validate:
   node glimmer-virtue-ethics/generate.js \
     glimmer-virtue-ethics \
     glimmer-virtue-ethics/index.html \
     --validate

   Expected: one warning (Turn 2 no virtuous option — correct, intentional).
   Any errors → stop and report.

4. Deploy:
   node glimmer-virtue-ethics/generate.js \
     glimmer-virtue-ethics \
     glimmer-virtue-ethics/index.html \
     --nextjs .

5. Verify:
   ls -la public/games/character-drift/
   grep "_mechanic_argument" public/games/character-drift/user-config.js
   grep "drift_check_turns" public/games/character-drift/user-config.js

   Expected:
   - index.html, user-config.js, assets/
   - _mechanic_argument appears only in the comment
   - drift_check_turns: [4, 7, 10]

6. Commit:
   git add public/games/character-drift/
   git commit -m "feat: add character-drift starter template (virtue ethics)"
   git push origin main

Report: validation output, directory listing, grep results, commit hash.

Expected output: public/games/character-drift/ deployed. drift_check_turns in user-config confirms engine receives correct check points. Committed to main.

Handoff condition: Directory exists. _mechanic_argument comment-only. drift_check_turns array present in user-config. Commit pushed.

Dependency: None.


Step 2 · Phase F · Human Task

Labor: Human · [PA] Plausibility Auditing

Verify the card and game load correctly. One additional check specific to this engine.

Action

Check 1 — Card on /games: Card labeled "Character Drift" appears. Tags include "virtue ethics" and "ethical play."

Check 2 — Intro screen: Navigate to /games/character-drift. Verify three-step how-it-works explanation is visible. Begin button present.

Check 3 — Turn pips: After clicking Begin, verify 10 turn pips appear at top. Current turn pip is filled. No drift badge visible on Turn 1.

Check 4 — Drift badge appears on Turn 4: Play through Turns 1–3 (any choices). On Turn 4, verify the amber "Character check" badge appears in the header.

Check 5 — Blocking fires correctly: Play Turns 1–3 with "Defers to authority" choices (Turn 3: "Present as asked"). On Turn 4, verify "Back the technically correct solution" (Acts on principle) shows the lock icon and reason: "This choice conflicts with your established pattern of: Defers to authority."

Note: blocking at Turn 4 requires Defers to authority to be the PLURALITY card. Test this specific path:

This is the risk. See Step 3.

Handoff condition: Game loads, pips render, drift badge appears at Turn 4, character stack accumulates. Even if blocking doesn't fire on the test path above, the visual system is working.

Dependency: Step 1.


Step 3 · Phase H · Human Task

Labor: Human · [IJ] Interpretive Judgment

The highest-risk design question for this engine. Play three specific paths and record what happens at Turn 10.

Path A — Pure deference

Select "Defers to authority" wherever possible:

Path B — Pure delivery priority

Select "Prioritizes delivery over people" wherever possible:

Path C — Mixed

Alternate between types. Turn 10: record what happens. Does anything lock?

The judgment call: Does Turn 10 blocking happen reliably enough to produce the glimmer? With 10 turns and multiple card types, a player who makes varied choices may never establish a dominant pattern — meaning nothing blocks at Turn 10 and the glimmer doesn't land.

If Turn 10 blocking fires on Path A but not Path B or C: acceptable — Path A is the intended glimmer path. If it fires on none: the incompatible_patterns need adjustment. If it fires on all three: the dominance threshold may be too easy to hit.

Record: does the consistent_severe reveal state (3+ blocks across all three drift checks) appear for any path? That state has the strongest reveal text. If no path produces it, the game's most powerful moment is unreachable.

Handoff condition: At least Path A produces Turn 10 blocking and the consistent_severe or consistent_mild reveal state. If neither path produces blocking, note specifically which incompatible_patterns adjustment is needed before student use.

Dependency: Step 2.


Step 4 · Phase R · Human Task

Labor: Human · [EI] Executive Integration

Action

Handoff condition: Five games visible. Tags correct. Released.

Dependency: Step 3.


Score Summary

Count%
Total steps4
Claude tasks125%
Human tasks375%

The specific risk for this engine

The dominant pattern threshold.

With 10 turns and varied decisions, a player who makes genuinely mixed choices may never establish a dominant pattern. If getDominantPattern() returns null at every drift check, nothing ever blocks, and the mixed_mild or mixed_severe states are all that's reachable.

This is not necessarily a failure — the mixed states have their own reveal text. But the glimmer the spec describes — "Turn 10. The player wants to make a decision that contradicts their pattern. They can't" — only happens if blocking fires at Turn 10.

If Step 3 reveals the blocking is too rare: the fix is to add a third incompatible pair to incompatible_patterns, or to reduce the number of distinct card types across decisions so dominant patterns form faster. Both are game.json edits, not engine changes.

If blocking fires too easily on all paths: reduce distinct option cards per turn so the player has fewer ways to stay varied. Again, game.json, not engine.

This calibration is the one thing that cannot be checked without playing the game. Step 3 is where it happens.