Thom Miano

Case study · Katachi · the typing state

Iterative Design with an AI Agent: A Visual Case Study

  ▐▛███▜▌
 ▝▜█████▛▘
   ▘▘ ▝▝
 ┌──────┐
 │ >_   │
 │      │
 └┬────┬┘
▄▄██████▄▄
Figure 1 Initial sketch (left) and final animation, typing v36 (right). The whole study is the distance between the two.

Abstract

What do design, implementation, and iteration look like in an agentic-driven workflow? This page documents 36 iterations of bringing Claudito — a pixelated, four-legged Claude avatar — to life through conversation. Every prompt is quoted as written, next to what it produced, so the record reads as it happened: three ASCII explorations to find a composition, then thirty-six SVG versions in which the legs became tentacles, the keyboard became a real one, and the typing became real text.

Background

Claudito as drawn at the start of a Claude Code session
Figure 2 Claudito at the start of a Claude Code session.

Claudito is the name we gave to the Claude avatar—a pixelated, four-legged character that serves as a visual representation of the AI assistant. The goal of this exercise was to animate Claudito typing on a keyboard.

Prompt by Prompt

ASCII Exploration

Exploration 1: Laptop Concept

Can you come up with an example where claudito is typing on a laptop

Front view

     ▐▛███▜▌
    ▝▜█████▛▘
      ▘▘ ▝▝
    ┌──────┐
    │ >_   │
    │      │
    └┬────┬┘
   ▄▄██████▄▄

Dynamic arms

      ▐▛███▜▌
     ▝▜█████▛▘
       ▘▘ ▝▝
     ╭──────╮
     │ >_   │
     │      │
     ╰┬────┬╯
    ▀▀██████▀▀
      ▔▔  ▔▔

Side view

    ▐▛███▜▌
   ▝▜█████▛▘  ┌────┐
     ▘▀▀▘    ┌┤>_  │
       ──────┴┴────┤
        ▀▀▀▀▀▀▀▀▀▀▀
Figure 3 Initial ASCII exploration of Claudito at a laptop. Three compositions explored: front view, dynamic arms, and side view.

Exploration 2: Profile Laptop

Let's work through some more initial design sketches. I'm thinking of profile view of claudito facing a laptop, that way the laptop has the distinctive angled screen

Laptop profiles

    ╱│        /│        ▟│        ◢│
   ╱ │       / │       ▟ │       ◢ │
  ╱  │      /  │      ▟  │      ◢  │
 ────┘     ────┘     ▀▀▀▀┘     ════╛

Version A

        ▟│
  ▐█▛  ▟ │
  ▜██▄▀  │
   ▘▘ ▀▀▀┘

Version B

       ▟│
  ▐█▛ ▟ │
  ▜██▀▀ │
   ▘▘▔▔▔┘

Version C

         ◢│
  ▐█▛   ◢ │
  ▐██  ◢  │
  ▜██▄▀▀▀▀┘
   ▘▘
Figure 4 Profile view exploration with angled laptop screen. Multiple laptop angle styles and Claudito compositions tested.

Exploration 3: Keyboard Focus

let's try claudito typing on a keyboard

Version A

  ▐▛███▜▌
 ▝▜█████▛▘
  ╲▘▘ ▝▝╱
   ══════

Version B

  ▐▛███▜▌
 ▝▜█████▛▘
 ▘▄▘▘ ▝▝▄▘
  ▀▀▀▀▀▀▀

Version C

  ▐▛███▜▌
 ▝▜█████▛▘
 ▀ ▘▘ ▝▝ ▀
 ▄▄▄▄▄▄▄▄▄

Version D ✓

   ▐▛███▜▌
  ▝▜█████▛▘
  ▄ ▘▘ ▝▝ ▄
  ░░░░░░░░░

Version E

  ▐▛███▜▌
 ▝▜█████▛▘
 ◜ ▘▘ ▝▝ ◝
  ▀▀▀▀▀▀▀
Figure 5 Simplified to just keyboard (no laptop screen). Version D was selected as the direction for SVG implementation.

SVG Implementation

v1First SVG version based on ASCII sketch Version D. Rectangular legs and basic keyboard layout.I tihnk version D could be an interesting direction. The keys need to look more like distinctive keys, and we could leverage SVG for that, and we could leverage SVG for the actual legs typing on the keysclaudito-typing-v1.svg
v2Added wave-based typing animation. Claudito positioned closer to keyboard.There original four think legs should be preservered. I'm imaging they having kind of wave oscilations as the typing motion takes place. The claudito should be closer to the keyboard tooclaudito-typing-v2.svg
v3Added 3D key gradients. Exploring Perlin noise animation concept.The keys need to be more distinctive. Its difficult to see their differentiation. Here's a vague idea on the typing animation: - Each leg has it's own function that makes it mirror back and forth along both axes; oscillate along both axes; translate along both axes; - Each function uses perlin noise to give it a more natural motion effectclaudito-typing-v3.svg
v4Fixed leg anchors at body, stretching motion during typing.The back of the legs should be more fixed to the body, and they should stretch out during their movementclaudito-typing-v4.svg
v5Adjusted leg stretch range. Legs now target actual key positions.The stretch range needs adjusting. It needs to be able to reach the keys that are the maximum distance away. Can you make them intersect the actual positions of keys?claudito-typing-v5.svg
v6Faster key-to-key transitions to reduce teleportation effect.Can you make the key-to-key movement of an arm faster so that it doesn't look like its arm is teleporting to a new position?claudito-typing-v6.svg
v7Leg origins match body position. Left/right leg clusters stay on their respective sides.The origin of the legs connected to the base of the claudito should match the default position of the legs. The left cluster of legs should stay on the left side more and the right cluster of legs should stay on the right more. Less cross-leg crossing of legs in other clusters, except for inner legsclaudito-typing-v7.svg
v8Major shift to tentacle/bezier curve approach for organic movement.All of the legs are still overlapping at various points. Feel free to come up with a new typing algorithm without the constrains that I said. I want it to look like the claudito is typing simultatnousy with all four legs. The legs should stay anchor to their original position on its body though. The legs should tend to preserve their skinniness, but they can: - strech - twist - curve - move side to side. They don't have to stay straight. They typically shouldn't stay strait why they're typing. It should look more like an octopus... I guess a quadropusclaudito-typing-v8.svg
v9Added snappy tap movements with anticipation/strike/return phases.Yes, this is the eact dirction I was looking for! Can you give them more snappy tap movements, why leveraging the general movement that you've created?claudito-typing-v9.svg
v10Actual key targeting - legs reach specific key positions.This is looking really good. Now, can you make the snap-to-key action so that they actually reach the different keys?claudito-typing-v10.svg
v11Slower tap duration (0.40-0.45s) for visible motion.Can you make the snap motion slower so that we can actually see claudito reaching each keyclaudito-typing-v11.svg
v12More continuous typing with occasional pauses, same tap animation speed.From the v11 style, make less delay between each type, but don't make the snap animation faster. They typing itself should be more continuous for the most part, with occasional pausesclaudito-typing-v12.svg
v13Keyboard flipped - spacebar row closest to Claudito.The keyboard should be flipped so the space bar is facing clauditoclaudito-typing-v13.svg
v14Keyboard scaled down to match Claudito's width.Let's try a version where they keyboard is scaled down so that it's as wide as clauditoclaudito-typing-v14.svg
v15Full keyboard layout with 16:9 ratio, 5 rows including number row.Can you give the keyboard more of a 16:9 ratio and give it the full set of normal keys on the keyboard (where numbers are above the letters)claudito-typing-v15.svg
v16Scaled down smaller keyboard.Can you scale the keyboard down to make it smallerclaudito-typing-v16.svg
v17TKL-style keyboard based on screenshot reference.See the screenshot I took. can you make the key layout and ratio/proporitions like this?claudito-typing-v17.svg
v18Normal keyboard orientation - function row at top, spacebar at bottom.the keyboard looks off. I wonder if it's because we have the keyboard flipped toward the claudito? Also, remember to create a new file for each design iterationclaudito-typing-v18.svg
v19Fixed arrow keys - proper inverted-T shape with up arrow alone.This looks really close! I noticed that the arrows have three keys below them that shouldn't be there.claudito-typing-v19.svg
v20Data-driven keyMap approach with 87 keys generated from JavaScript object.Better, but still not quite there. Take a look at the schematic I took as the most recent screenshot in ~/Screenshots. Copy that into the project as a reference point and rename it as keyboard-schematic. I think one idea that might be helpful for you to nail the layout is to create a hash of all the keys shown in the screen shot, and then create a button for each one, that way you can validate the number of buttons, which button, and then their positionclaudito-typing-v20.svg
v21Fixed scale to fill keyboard width properly - keys were squished on left side.(Agent noticed scale bug from v20) Fixed scale from 0.38 to 1.25claudito-typing-v21.svg
v22Final alignment fixes: wider spacebar, function row gaps aligned with nav cluster.Wow this look awesome! Great job. Two small updates: - The space key needs to be bigger so that the right-most key (not the arrows) in that row is right justified with the keys above it - the gaps in the key groups on the top row need to be increased so that: (1) the last three keys are aligned with the three sets of keys below it; and (2) the key group of four before that are right-justified with the keys below themclaudito-typing-v22.svg
v23Keyboard rotated - spacebar row closest to Claudito, function row furthest away.For version 23 can you rotate the keyboard so that the spacebar is facing claudito?claudito-typing-v23.svg
v24Added key press animation - keys flash bright blue (#a6aaf1) when tapped.For each key that gets tapped, can you add a little color animation on the key itself, using the bright blue colorclaudito-typing-v24.svg
v25Claudito types actual text - Asimov's Three Laws of Robotics. Characters mapped to real keyboard keys.Claudito needs to use the space bar a lot more often. Hey! Here's an idea, what if we gave it an actual string of text to type, and then it types the 'real' (mapped) keys on its keybaord? Something like: The Three Rules of Robotics are: - A robot may not injure a human being or, through inaction, allow a human being to come to harm. - A robot must obey the orders given it by human beings except where such orders would conflict with the First Law. - A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.claudito-typing-v25.svg
v26Adjusted tentacle regions so the right tentacle covers more common keys (P, L, PERIOD, SEMI, QUOTE, ENTER).This is really fantastic. Would it be possible to make the right-most tentacle type more frequently (not just what looks like the shift or enter key)?claudito-typing-v26.svg
v27Case-sensitive typing - Shift key is pressed before uppercase letters.For the prompt and what gets typed, can you make it case sensitive if it isn't already so that Shift button gets clicked by claudito? We can skip this if it's too complicatedclaudito-typing-v27.svg
v28All keys glow golden yellow with gentle pulsing when Claudito finishes typing, then restarts.Can you make all of the keys glow the golden yellow color when claudito reaches the end of typing all of the laws? followed by Can you make it a glow gently in and out and then have claudito start from the beginning?claudito-typing-v28.svg
v29Golden glow pulses 3 times with longer ramp (2s cycles), 80% max brightness, then restarts typing.Can you update the glow so that it only does the glow pulse 3 times, when it does glow its ramp up and ramp down are stretched out a bit longer, and the maximum glow is 80% as bright?claudito-typing-v29.svg
v30Golden glow pulses 2 times (0%-75% opacity), then restarts typing.For the next version, can you give it only two pulses, make the maximum glow effect 75%, and make it so that the glow cycle reaches 0% opacity during the glow cycle. So 0-75%. After the second pulse reaches 0, there shouldn't be any further flash. The animation should start from the beginningclaudito-typing-v30.svg
v31Two-layer approach: base grey keys always visible, golden overlay fades 0%-75% so grey shows through at 0%.During the glow sequence, when I say 0% i mean that 0% should be the base color of the keys (the grey color)claudito-typing-v31.svg
v32Golden glow max opacity reduced to 50%.in a new sketch, can you make the glow maximum opacity 50%?claudito-typing-v32.svg
v33Cascading glow follows typed key order, then all keys pulse to 50%, then restarts.What do you think about this: When claudito complete typing, each key fills up in sequence with a slight golden yellow, then it pulses up to 50% and then claudito starts over? followed by Let's try following the order of keys that were typed first. That's an interesting idea!claudito-typing-v33.svg
v34After cascade, ALL keys (not just typed ones) light up and pulse together to 50%.After the cascade finishes, can you have all keys pulse together up to 50% like in version 32?claudito-typing-v34.svg
v35Typed keys cascade, then remaining keys cascade right-to-left bottom-to-top, then all pulse twice.How about after the type keys illuminate, the remaining keys glow up to the brightness that the typed keys are illumated using a sequence from right to left, bottom to top, then they all do the two sequence pulseclaudito-typing-v35.svg
v36Fixed tentacle anchors: closed gap (y=32) and repositioned right tentacles closer to center.The tentacles aren't (visually) attached to claudito the right way: 1. There's a gap between the lower body and the legs 2. The right set of tentacles aren't in the right position for where they should be. They're too far to the rightclaudito-typing-v36.svg

Figure 6 All thirty-six SVG versions in order, each with the prompt that produced it, quoted as written. Animations play only while on screen and pause as soon as they scroll out of view.

Key observations

This exercise demonstrates some key observations for a collaborative workflow with an AI agent.

  1. Methods can be over-prescriptive. In some cases, defining the method to use seemed to be too restrictive and didn't result in the outcome or visual feeling intended. v3
  2. Describe feelings, not implementations. It often proved more productive to describe the intended feeling with different ranges of vocabulary that could communicate the idea. v8
  3. Screenshots enable shared vision. A very powerful way to provide feedback to the agent was through screenshots, enabling the agent to see as I see on the other side of the screen. v17
  4. Precision with latitude. Instructions that were simultaneously quite specific but also somewhat vague were able to be interpreted and executed on accurately and to the precise specification intended. v22
  5. Feel is iterative too. Later iterations showed how subjective feedback about feel can drive refinement. The completion celebration went through eight versions, with prompts like "make the glow pulse 3 times" and "the maximum glow is 80% as bright" fine-tuning the emotional payoff until it felt right. v28–v35

Hover a version to preview it on the right; click to go to its card.

Design evolution

The journey from v1 to v36 followed a natural progression:

v1–v6
Basic animation, rectangular legs
v7–v8
Organic bezier tentacles
v9–v22
Keyboard interaction, key mapping
v23–v27
Real text typing with shift keys
v28–v35
Completion celebration sequence
v36
Final polish, tentacle positioning

Hover to see the version

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
Figure 7 The thirty-six versions as a timeline. Fourteen of them — more than a third — went to getting the keyboard right.

Agent reflections

From the agent's perspective, this workflow highlighted the value of iterative refinement over upfront perfection. Each version built on the last, with human feedback steering direction while preserving creative latitude. The shift from rectangular legs to organic bezier tentacles (v7→v8) emerged not from explicit technical instruction, but from understanding the desired feeling—"quadropus"—and translating that into appropriate techniques.

The data-driven approach in v20 (using a keyMap hash) exemplifies how a well-timed structural suggestion from the human—"create a hash of all the keys"—can unlock cleaner solutions. Sometimes the best contributions aren't about doing more, but about reframing the problem.

The final stretch (v28-v36) revealed something else: feel is iterative too. The golden glow celebration went through cascading sequences, pulse timing adjustments, and opacity tweaks—each change small, but together transforming a functional completion state into a satisfying moment. The last fix (v36) addressed tentacle attachment points, a detail that only became apparent after everything else was working.

Page evolution

The case-study page itself went through four versions. Each opens the original file.

  1. v1: Initial GridBasic grid layout with system fonts and simple dark styling. Just title and cards.
  2. v2: Context AddedAdded context section with agent-edited observations (bold headings, refined wording).
  3. v3: Showcase AddedHero animation showcase added under title to highlight the final result.
  4. v4: Final PolishDesign Evolution milestones, 5th observation, expanded reflections, golden highlights.

Colophon

Implementation

The final animation is a single self-contained SVG (22 KB) with its script inline; it has no dependencies and runs anywhere an SVG can. The keyboard is generated from a keyMap of 87 keys — a tenkeyless layout, each key a row, offset and width in key units — so the layout could be validated key by key against a schematic. Each of the four tentacles is one cubic Bézier path whose two control points are pushed off the straight line by four independent 1-D Perlin noise channels (two curls, a sway and a hover), with a tap curve that anticipates, strikes and returns to hit a target key. The text is Asimov's Three Laws, typed character by character through a character-to-key map, with Shift pressed for capitals. One requestAnimationFrame loop drives it all and honours an isPaused flag, which this page uses to stop any version that is not on screen.

Cite

Thom Miano & Claude Opus-4.5 (2026). Iterative Design with an AI Agent: A Visual Case Study. thommiano.com, January 24, 2026.

@misc{miano2026iterative,
  title  = {Iterative Design with an AI Agent: A Visual Case Study},
  author = {Thom Miano and Claude Opus-4.5},
  year   = {2026},
  month  = {January},
  note   = {Claude Code 2.1.15},
  url    = {https://thommiano.com/iterative-design-with-an-ai-agent/}
}