Development journey: "Clawd: Mannered Prose", a 15-second cartoon made only with code

Date: 2026-09-24  ·  Model: Claude Opus 5.5 (1M context), in Claude Code v2.1.281, medium effort, bypass-permissions mode  ·  Advisor model: Fable 5.1
Deliverable: clawd-prose/out/clawd-prose.mp4 (8,693,220 bytes, 1920×1080, 24 fps, 360 frames, 15.000 s, H.264 + AAC)
Source: clawd-prose/ (1,349 lines in 8 files)  ·  Plan: implementation-plan.html

1. The brief

You gave the brief in two parts. The first part came from the prompt in the reference YouTube video (dT8OM3cqrMo, "I Asked Claude OPUS 5.5 to Make a Cartoon From Scratch... and It Did!"). The second part was your own storyboard, my_storyboard.txt. The session 1 prompt, verbatim:

Create a 15-second animated video starring the Claude Code mascot, Clawd—the small orange pixel-style character. Use an accurate reference for its appearance. Build it from scratch using p5.js and p5.brush, with a warm watercolor background and playful cartoon movement. The storyboard is in @my_storyboard.txt. Do not create the video yet. do all needed preflight checks. make sure everything is ready. ask me if any question

The storyboard has 5 beats with fixed times: 0–3 s "The innocent question", 3–7 s "The Mannered Prose Machine awakens", 7–10 s "Concision makes everything worse", 10–13 s "Anthropic intervenes", 13–15 s "Recovery… almost". It ends with the text "Be direct." and a cut to black. my_prompts.txt adds the output rules from the reference prompt: 1920×1080, 24 fps, exactly 15 seconds, MP4, Puppeteer and FFmpeg, "inspect sample frames and the finished video; fix any visual errors", "deliver the MP4 and runnable source". It also says "you also have access to pixabay api. the key is in the env" and "music is all code as well".

In session 3 you asked "can you finish all the 8 phases in one go", and then answered "A. one go". Option A meant three things: use the Clawd grid that I decoded by hand, do not stop at the 3 review checkpoints, and report everything at the end.

How I read the brief (choices I made without asking)

• "No captions or dialogue" in the reference prompt conflicts with a storyboard that is mostly text. I treated text that is inside the scene as allowed: the laptop screen, speech bubbles, the system card, words painted on objects. I did not add subtitles.
• "Clawd sits at the laptop": Clawd stands to the right of the laptop and faces it. A 264-px-wide pixel block cannot sit on a chair and still read as Clawd.
• "The user": a round blue face with dot eyes in the upper left. It is not a real person.
• All the prose that the storyboard does not give I wrote myself: the two wedge sentences, the 470-character paragraph, the bullet text "And that matters.", the label "PROSE-O-MATIC", the header "SYSTEM MESSAGE" and the prompt label "claude".

2. The whole process on one page

No AI model generates pixels in this project. The model writes a program. The program draws 360 still pictures. FFmpeg joins them into a video. A second program calculates the sound as a list of 720,000 numbers. The model then looks at sample pictures, finds errors, and changes the program.

3. Three sessions: timeline

The work used three Claude Code sessions in the same folder on 2026-09-24. You ran /clear between sessions 2 and 3. HANDOFF.md carried the state across the clear.

Times come from file timestamps and the saved terminal text. Session 3 build time: the clawd-prose/ folder was created at about 15:20, and the last render finished at 16:30, so about 70 minutes. reconstructed for sessions 1–2

4. Session 1: preflight and your 3 decisions reconstructed

Session 1 made no video. It checked that each tool works on your machine, and it found the facts that the design depends on.

Two errors happened during the binary search. Both were Windows encoding problems:

UnicodeEncodeError: 'charmap' codec can't encode characters in position 0-4: character maps to <undefined>

Python printed to a cp1252 console. The fix was PYTHONIOENCODING=utf-8. Then a regex over the raw bytes failed on the mixed binary text, and the search changed to a plain UTF-16-LE byte search.

Your 3 decisions (asked with a multiple-choice question)

5. Session 2: the plan reconstructed

You asked for a detailed, step-by-step implementation plan that explains each tool. The result is implementation-plan.html (609 lines when first written, 57,732 bytes), with 12 sections. It set the architecture that session 3 then followed:

• Paint once, move many times. p5.brush is random and slow. If it painted the wall again for each frame, the edges would move 24 times each second ("boiling"). So each item is painted one time and kept as an image.
• Each frame is a pure function of time. Frame i shows t = i/24 s and depends on nothing else.
• Two canvases. A hidden WebGL canvas for p5.brush painting, and a visible 2D canvas for each frame.
• One cue file, cues.json, that the picture and the sound both read.
• 8 phases with checkpoints.

The advisor (Fable 5.1) reviewed the plan in session 2. The saved terminal text shows 2 or 3 calls; two lines may be one call. You then asked me to publish it as a private artifact (version 1, icon "film"). Then you ran /handoff-after-clear, which wrote HANDOFF.md (41 lines).

6. Session 3: the build, phase by phase

Session 3 started from a clear context. It read HANDOFF.md, TASKS.md, README.txt, my_prompts.txt and my_storyboard.txt, then re-checked the tools. Before the build it found 3 small gaps and told you about them:

1. The latest p5 on npm was 2.3.3, but the smoke test used 2.2. The install command in the handoff (p5@^2.2) would get 2.3.3. I pinned p5@~2.2, which installed 2.2.3.
2. The Clawd head row was still not checked against a live terminal.
3. The status bar showed "Update installed · Restart to update". A restart would not affect the build.

You chose option A (one run). Then I extracted the plan from the HTML into plain text (39,638 characters) and read all of it before I wrote any code.

Phase 1: pipeline proof

I wrote render.mjs: a Node http server on port 8765, Chrome through puppeteer-core, a loop of page.evaluate(renderFrame(i)) plus a screenshot for i = 0…359, then FFmpeg and ffprobe. The test scene drew one watercolor rectangle and the text "frame N".

assets painted in 1856 ms
360 frames, 120 ms per frame
stream|codec_name=h264|width=1920|height=1080|pix_fmt=yuv420p|r_frame_rate=24/1|duration=15.000000|nb_read_frames=360

verified The checkpoint passed on the first run: 360 frames, 24/1 fps, 1920×1080, 15.000 s. The log also showed [page] Failed to load resource: the server responded with a status of 404 (Not Found). I made the server log each 404 URL except favicon.ico. No other URL was ever logged, so the 404 is Chrome's automatic favicon request.

The first advisor call: 2 problems that would have cost a full repaint

I called the advisor after phase 1. It looked at the test frame and found that the upper-right part of the painted rectangle was nearly white, not paper-coloured. p5.brush mixes pigment with the canvas colour, and I had painted on white. Every prop would look chalky on the paper background. The fix was one line: paint on the paper colour #f3e6cf. It also warned that the Clawd orange would drift, because a watercolor fill averages lighter than its colour. So the body is a flat #D77757 fill with a texture on top in soft-light mode, and a check in code measures the mean colour. The same advice suggested a larger brush scale (3 → 6) and a byte-for-byte determinism check. I applied all of it.

Phase 2: paint the world

I wrote 23 sprite paintings. The first asset sheet showed pale, patchy colour, and some p5.brush marks that did not work (section 13). The second sheet was good. Painting all 23 sprites takes 7.5–11.6 s at the start of each render.

Phase 3: build Clawd

I wrote clawd.js and rendered a pose sheet with 8 poses. The colour check printed clawd mean rgb 215,119,87 (target 215,119,87). verified

Phase 4: animate the 5 beats

I wrote the timeline code for all 5 beats in one pass, about 600 lines. Then I rendered 6–12 stills for each beat, read them as one tiled image, and fixed what I saw before I went to the next beat. There were 9 still passes in total. Section 12 explains how this loop works.

Phase 5: sound

I wrote score.mjs (127 lines). It runs in 0.7 s. The first waveform showed that 5 thuds set the peak level and made the music quiet. I rebalanced the mix one time (section 11).

Phase 6 and 7: full render, check and fix

There were 5 full renders in session 3: the phase 1 test, a silent draft, the first render with audio, a render after the transition fixes, and a final render after the last pose fix. Section 13 lists every fix.

Phase 8: deliver

I deleted out/frames/ (360 PNG files), wrote README.md with the 3 run commands, added npm scripts, and updated TASKS.md and HANDOFF.md. I sent you the MP4 and the contact sheet.

7. How each asset is designed

An "asset" here is a sprite: an image that is painted one time and then moved, turned or stretched in each frame. All 23 sprites are defined in part 1 of scene.js, and paint.js paints them.

7.1 How one sprite is made

1. addSprite(name, w, h, paint, mask, bg) puts a job in a queue. Each job gets its own seed: 1000 + index × 17.
2. p5 calls draw() about 60 times each second. Each call clears the hidden 1920×1080 WebGL canvas to the job's background colour, calls randomSeed(seed) and noiseSeed(seed), and runs the job's paint function.
3. p5.brush does not show its paint until the end of draw(). So the copy happens at the start of the next draw() call. This detail came from reading src/adapters/p5/addon.js: the flush happens in the postdraw hook.
4. The copy uses a mask: the job's shape path, filled and then stroked 8 px wide. The painting is drawn with source-in, so only the pixels inside the shape stay. The 8-px stroke keeps the ink outline, which sits on the edge of the shape.
5. When the queue is empty, the page loads cues.json, waits for the Georgia and Consolas fonts, draws frame 0, and sets window.READY = true. The renderer waits for that flag.

7.2 The painting vocabulary

Every sprite uses 3 helpers from paint.js:

• wc(color, alpha, bleed, texture, border): a flat brush.wash at opacity 170 for solid colour, plus a brush.fill on top for the watercolor bleed, the grain and the darker rim. The flat wash was added after the first asset sheet looked patchy.
• tex(...): watercolor only, no flat wash. It is used for overlay textures, smoke and window light.
• ink(color, weight): the p5.brush 'pen' brush for outlines. It gives a slightly broken, hand-drawn line.

7.3 All 23 sprites

Items that are not sprites (drawn with Canvas 2D code in each frame)

All text, the em dashes (rounded bars), the SEAMS stitches, the "quietly" legs, the sparks and impact stars, the sweat drop, the "!" mark, the ghost bow tie, the glasses, the light rays, the siren wash, the vacuum hose, the suction lines, the speed lines and the vignette. They change shape or text in each frame, so a painted image would not help.

8. How Clawd is designed

8.1 From terminal characters to a pixel grid

The Claude Code terminal draws Clawd with block characters. Each character cell has 2×2 "quarters" that are on or off. A terminal cell is about twice as tall as it is wide, so a quarter is a tall rectangle. In the video, 1 quarter is 22×44 px.

The code (clawd.js) uses grid A: body columns 3–14 and rows 0–3 (264×176 px), eyes in row 1 at columns 5 and 12, arm nubs in row 2 at columns 1–2 and 15–16, legs in row 4 at columns 4, 6, 11 and 13. The origin is the centre of the feet, so squash and stretch keep the feet on the desk. Clawd is 264 px wide without the arms and 220 px tall.

 ▐▛███▛█
▝▜██████▀
  ▝▝ ▝▝

8.2 How the body is drawn in each frame

1. A soft shadow ellipse on the desk. It does not squash, and it shrinks when Clawd is in the air.
2. Translate to the feet, rotate by lean, scale by sx, sy.
3. The body and legs as one Path2D, filled flat #D77757.
4. The arm nubs. Each nub turns about a pivot on the outer edge of the body. The reference repo lists a known bug: arms that turn about a point inside the body disappear into it. The nub grows longer as it lifts: 44 + 22·|sin(angle)| px, plus an optional extra.
5. The texture: clip to the body and draw clawdtex in soft-light at 45%.
6. The eyes, in one of 8 modes.

8.3 Acting with no mouth and no hands

Follow-through. clawdPose(t) blends the arm angles of the last 3 frames (weights 0.55, 0.30, 0.15). This makes the nubs trail the body for 2–3 frames. It stays a pure function of t, because it only calls rawPose at earlier times. This was not in the plan. I added it after the motion check found about 20 arm jumps between two frames.

9. How each frame is designed

9.1 The rule: frame i is a function of t = i / 24 only

renderFrame(i) never uses the previous frame. A bounce is "height = 70·sin(π·k)" for a progress value k from 0 to 1, not "5 px higher than last time". Random items (confetti-like puffs, sparks) use a seeded generator, rng(seed). The result:

• A frame can take 50 ms or 2 s to draw, and the video timing does not change.
• Any frame can be rendered alone, for example node render.mjs --stills 8.6.
• The same code gives the same frames. verified Frame 0 was byte-identical across two full renders (cmp).

9.2 The time toolkit

9.3 The layer stack, shown on a real frame

Frame 132 (t = 5.500 s) built one group at a time. I made these images for this document with a separate script. It turns off groups of drawing functions and renders the same frame again.

The full order inside renderFrame:

1. Clear, then apply the camera shake (the sum of 4 decaying shakes: beam 4.6 s, pile 7.0 s, slam 8.05 s, card 10.5 s).
2. Room sprite, then the light rays (10.0–12.35 s).
3. Back props: laptop and its screen, machine and gears and smoke, PROSE switch, CONCISE button, paper pile with the paragraph.
4. Gags: ribbon, wedge, SEAMS, beam, key, "...", bullets, 2 em dashes, "quietly", puff bursts. Each gag is skipped after its vacuum time.
5. Clawd, then his extras (sweat, "!", bow tie, stars, speed lines), the paper strip and the stamp.
6. Foreground: the avatar with glasses, magnifier and thumbs-up, the 2 speech bubbles, the system card, the vacuum, and the words flying into the vacuum.
7. Outside the camera shake: the red siren wash, the grain (multiply, 35%) and a radial vignette.
8. From 14.92 s: black.

9.4 How text is drawn

• All text is Canvas 2D fillText. WebGL text in p5 needs a font file to be loaded first, so the plan kept all text off the WebGL canvas.
• Georgia for prose, Consolas for the laptop. The page waits for both fonts before frame 0.
• The ribbon. The 2D canvas cannot draw text along a curve. The code builds an 11-point path, measures the arc length, and places each letter one by one, turned to the path direction. The paper strip is the same path stroked 70 px wide (dark) and then 64 px wide (cream).
• Wrapping. The canvas does not wrap text. wrap() measures each word with measureText and breaks the lines.
• The CONCISE joke. The compressed paragraph is the same text and the same layout, scaled to 34%. It really has the same amount of prose.

10. The shot list as it was built

All times come from cues.json. The beat borders (0, 3, 7, 10, 13, 15 s) are yours. I set every time inside a beat.

11. How the music and sound are made

11.1 Sound as numbers

A WAV file is a 44-byte header plus a list of numbers. Each number is the position of a speaker cone. This build uses 48,000 numbers each second, so 15 s is 720,000 numbers. One video frame is exactly 2,000 samples (48,000 / 24), so frame i starts at sample i × 2,000. That exact ratio makes the sync simple. score.mjs uses no audio library. It adds every sound into one Float32Array, limits the peaks, and writes 16-bit PCM itself.

11.2 The instruments

11.3 The vibe, section by section

The tempo is 120 beats each minute, so one beat is 0.5 s. Each storyboard beat starts on a musical beat: 0, 3, 7, 10 and 13 s are beats 0, 6, 14, 20 and 26. The music and the picture change at the same moments.

11.4 Sound effects and timing

About 30 effects. Each one starts at a time from cues.json, the same number the picture uses. Sound can start on any sample, but the picture changes only every 41.7 ms. So each hit starts on the first sample of its impact frame, never before it. The plan quoted ITU-R BT.1359 from memory: people notice early sound more than late sound (about +45 ms early, −125 ms late). not verified I did not check those figures.

The effects: bubble pop, key clicks (10, then 9), backspace clicks, cloth rustle, 2 knuckle cracks, ratchet, lever clunk and spark, the transformation whoosh, gear clanks, paper swish, machine rattle at 11 Hz (the same rate as the machine shake in the picture), steam hiss every 0.3 s (the same rate as the chimney puffs), beam thud, stitch zip at 30 clicks each second, hammer "tink", boomerang whooshes every 0.35 s, tiptoe plinks every 0.1 s, "blip-blip" for each bullet, paper avalanche, message ping, slam, compressor zip (1,200 → 200 Hz), stamp thunk, 3 glasses clicks with rising pitch, card thud, a siren from 600 to 1,200 Hz twice each second (the same rate as the red wash), the vacuum roar, 11 rising "fwips" (one for each word), the send whoosh, the thumbs-up ding, a "boing", and the last vacuum with a pop.

11.5 The mix, and the one rebalance

1. Every sample goes through tanh(1.2·x), a soft limiter.
2. The whole mix is scaled so the loudest sample is −1 dBFS.
3. 12.3–13.0 s and 14.92–15.0 s are set to zero, with a 10 ms fade at each edge to prevent a click.

In the first waveform, 5 long thuds (a sine gliding from 110 to 40 Hz over 0.35 s, amplitude 0.8) set the peak level, and the march was about 4× smaller. The siren and vacuum were almost invisible. I made the thuds 55% quieter and 0.18 s long, raised the siren from 0.09 to 0.13, and raised the vacuum from 0.22 to 0.7. The normalization gain went from 1.00 to 1.26.

verified Peak −1.0 dBFS, mean −14.5 dB, 720,000 samples, 12.31–12.99 s at −91 dB (that is, zero), 14.93–15.0 s at −91 dB. not verified How it sounds. I cannot hear. Nobody has listened to it yet.

12. The core problem: checking a film without watching it

I can read images. I cannot watch motion and I cannot hear. So each check turns the video into something I can read.

The motion-check limits are my own choice. They are not a standard. Speed, rhythm, comic timing and reading time can only be judged by a person who watches the video.

13. What went wrong, and the fixes

13.1 Errors with error text

1. FFmpeg glob. The first try to tile stills failed:

   [image2 @ 000001ff4e768400] Pattern type 'glob' was selected but globbing is not supported by this libavformat build
   Error opening input file t_*.png.

   The Windows "essentials" build of FFmpeg has no glob support. Fix: write a list.txt file and use the concat demuxer (-f concat -safe 0).
2. A newline inside a JavaScript string (twice). I edited render.mjs with a Python script inside a Bash heredoc. The '\n' in the JavaScript became a real line break:

   SyntaxError: missing ) after argument list      (render.mjs:66)
   SyntaxError: Invalid or unexpected token        (render.mjs:56)

   The same mistake happened twice. Both were fixed with a direct text edit. Rule: do not write escape sequences through two layers of quoting.
3. 404 in every render. [page] Failed to load resource: the server responded with a status of 404 (Not Found). I added URL logging. Only favicon.ico is missing. This has no effect on the result.

13.2 Visual errors found in stills, and the fixes

13.3 Near-misses caught before they ran

• A global function drawSheet (the paragraph) had the same name as window.drawSheet (the check sheets). Global functions in a browser script are properties of window, so one would have replaced the other. I renamed the paragraph function to drawParagraph before the first run.
• A nonsense expression in the delete logic, typed(...) && LINE1.slice(...), was replaced before the first run.
• Seeding with brush.seed (section 7.1).

14. Where the result differs from the storyboard

Reading time: "Be direct." is on screen for 0.52 s (it fades in over 0.1 s). "The real lesson isn't brevity. It's—" types over 0.45 s. A common subtitle rule of thumb is 15–20 characters each second. not verified as a standard. At that rate, 36 characters need about 2 s. The joke still works because the line is cut off. You kept 15 s, so I did not extend it.

15. Tools used

Not used: Pixabay (no audio API), Higgsfield (your README says "no higgs"), the hyperframes skill (you chose p5.js), any AI image, video or audio generator, any video editor.

16. Agents, advisor, and the rules that shaped the work

• No subagents. All the work was done in the main session. Parallel agents would not help, because each step depended on looking at the output of the step before.
• Advisor (Fable 5.1), session 3, 2 calls. Call 1, after phase 1: paint on paper colour, use a flat Clawd fill plus a measured texture, log 404 URLs, scale brushes up, check determinism, render stills for each beat, check audio with numbers, keep 15 s without asking, carry the grid risk into the report. Call 2, before "done": read the final contact sheet (I had not), fix the 12.083 s lean jump from my own motion log, remove a wrong count ("9 visual errors") from TASKS.md and list the fixes instead, and send you the files. I applied every item. Session 1 had 1 advisor call, and session 2 had 2 or 3. reconstructed
• Your standing instructions: ASD-STE100 writing, plain language with full substance, precise phrasing (no rhetorical claims), dark HTML (this page), "finish, or say what you left".
• Hooks: one hook pushed toward the smallest change. Another asked for a finish line, a TASKS.md checklist and the "Blocked on me / Changed / Found" report.
• Deliberate additions beyond the plan: paint.js as a separate file, the --motion, --sheet and --stills modes with tiling, the arm follow-through. Each one was added because a check needed it.

17. Costs, limits and time

• Money: no paid API and no paid service. The work ran on a Claude subscription plan.
• Context: by the end of the build, session 3 used about 298,000 context tokens (a hook reported this number). Each turn in a context this large costs 3× or more than a turn at the start of a session.
• Render time: the phase 1 test scene took 120 ms per frame. The full scene took 814–1,018 ms per frame, so one full render took 5–6 minutes. I did not measure how much of each frame is drawing and how much is PNG screenshot encoding.
• Other times: sprite painting 7.5–11.6 s for each render, score.mjs 0.7 s, session 3 build about 70 minutes.
• Disk: 360 PNG frames existed during each render and were then deleted. node_modules is 96 MB. The MP4 is 8.7 MB, and score.wav is 1.44 MB.

18. Verification: what was checked and what was not

19. Unknown unknowns: questions you did not know to ask

Each item is a question that a person who directs this kind of work usually does not think to ask. Each has an answer.

About what the model can and cannot do

Did the model watch the video?

No. It read about 70 single frames and 3 contact sheets as images. It judged motion only from the numbers of the motion check. It has never seen Clawd move.

Did the model hear the music?

No. The first person to hear the soundtrack is you. The music is designed from music theory (tempo, chords, instruments) and checked as a waveform and as levels. Plan for at least one round of sound changes.

Is any part of this made by an image, video or music AI?

No. Every pixel comes from a drawing command in the source, and every sample comes from a formula in score.mjs. The only randomness is seeded, so it repeats.

How much of this did the model decide, and how much did you decide?

You decided: the story, the 5 beat borders, 15 s, p5.js + p5.brush, all-code audio, writing the engine from scratch, and one run without stops. The model decided: every position, every time inside a beat, all the extra prose, the colours, the instruments, the chords and the order of the vacuum words.

About the pictures

Is the watercolor animated?

No. The watercolor texture is painted one time and does not change. That is on purpose: painting it again for each frame would make it flicker. What moves is the position, turn and size of the painted images.

Why is Clawd flat, when the room is watercolor?

Clawd is a pixel character, and its colour must be exact. A watercolor fill changes the colour and softens the edges. So the body is flat #D77757 with a light texture in soft-light mode, which keeps the mean colour exact. The grain layer over the whole frame also covers Clawd, so it sits in the same paper world.

Why does the text look sharp and digital?

All text is drawn with Canvas 2D in system fonts, not painted with p5.brush. Painted text would be hard to read, and WebGL text needs font files.

Does the result depend on my computer?

Yes, in 3 ways: the fonts (Georgia, Consolas), the Chrome path in render.mjs, and the FFmpeg path. The GPU affects only the speed.

About the process

Was the first render the final one?

No. There were 5 full renders and 9 still passes in session 3. About 21 visual problems were found and fixed. Most time went into check-and-fix, not into first drafts.

Why were all 5 beats written before any stills were read, when the plan said one beat at a time?

That is a deviation from the plan. I wrote the timeline code for all 5 beats in one pass, because the beats share helpers and layers. Then I read stills beat by beat and fixed each beat before I moved on. The review happened for each beat. The writing did not.

What did the checkpoints you skipped (option A) cost?

The asset sheet, the pose sheet and the score were not approved by you before the build continued. If you do not like a prop, a pose or the music, it must be changed now, and the whole video must be rendered again (5–6 minutes). No step before it has to change.

How do I change something small?

Timing: change one number in cues.json, then run node score.mjs and node render.mjs. The picture and the sound move together. Position or size: one number in scene.js. Clawd's shape: the grid constants at the top of clawd.js. Colour: the COL palette at the top of scene.js. To check one moment without a full render: node render.mjs --stills 8.6.

Can someone else run it?

Yes, with Node 22, Chrome and FFmpeg, after changing the 2 paths at the top of render.mjs. The README has the 3 commands.

About accuracy

Is this really how Clawd looks?

The colour is confirmed from the Claude Code binary. The shape is not confirmed. See section 8.1: the grid I used, the logo text saved from your terminal, and the reference video disagree.

Which words on screen come from you, and which from the model?

From your storyboard: "Explain this simply.", "Change the parameter.", "PROSE", the ribbon sentence, LOAD-BEARING, SEAMS, WEDGE, QUIETLY, "Can you be concise?", "CONCISE", "AND THAT MATTERS.", "PLEASE REMOVE ALL MANNERED PROSE.", THE REAL UNLOCK, "The real lesson isn't brevity. It's—", "REMOVE MANNERED PROSE", "Be direct.". From the model: "It's not a tweak." / "It's a reckoning.", the 470-character paragraph, "And that matters." bullets, "PROSE-O-MATIC", "SYSTEM MESSAGE", "claude", "~ flourishes ~", "• third bullet".

Is the output legal to share?

The libraries are LGPL-2.1 (p5), MIT (p5.brush) and Apache-2.0 (puppeteer-core). The video contains no library code. Clawd is Anthropic's mascot. I did not check the rules for using the mascot. not verified

About the files

What was deleted?

The 360 PNG frames after each render, the stills folder, the intermediate video.mp4, and the session 1–2 scratchpad smoke test (lost at /clear; plan-smoke-frame.png is the record). Nothing in your project folder was deleted.

What was saved for the next session?

HANDOFF.md (state, the list of fixes, the next task), TASKS.md (checklist), clawd-prose/README.md. No new memory file was written in session 3. The agent's memory files about FFmpeg and Clawd are from sessions 1–2.

Where do the images on this page come from?

The folder journey/. The layer images and beat stills were made for this document by a script in the session scratchpad (layers.mjs). The script is not kept, because it is not part of the project. It turned off groups of drawing functions and rendered frame 132 again.

20. Where things stand

• Done: clawd-prose/out/clawd-prose.mp4 and the runnable source in clawd-prose/.
• Blocked on you:
  1. Watch the video and listen to it. Send notes on timing, readability and sound.
  2. Send a screenshot of the Clawd logo in your terminal, so I can settle grid A or grid B.
  3. Decide whether reading time is worth more than the 15-second limit. Options: keep 15 s; move 0.3 s from the silence to "Be direct."; or extend beat 5 by 1–2 s.
• Possible next steps: a sound pass after you listen; the grid fix; package the pipeline as a reusable skill, as the reference video did.

This document: DEVELOPMENT-JOURNEY.html at the project root. Images: journey/. Sources: the session 3 transcript, .ignore/cc1_cartoon.txt, .ignore/cc2_cartoon.txt, .ignore/Screenshot (2102).png, implementation-plan.html, HANDOFF.md, TASKS.md, and the files in clawd-prose/.