show-me: een coding agent skill voor compacte visuele weergaven

Kort samengevat: zorg dat je agent visueel communiceert in plaats van in lange muren van tekst.

npx skills add humanlayer/skills --skill show-me

Lichter en sneller dan HTML, en voldoende voor de meeste problemen die voorkomen bij programmeerwerk.

Coding agents zijn vrijwel onleesbaar

Verschillende experts wijzen op dit probleem:

Dillon Mulroy heeft zelfs een skill gemaakt, /bro, om het model te vragen de taal te vereenvoudigen: https://x.com/dillonmulroy/status/2079238358358778142. De inhoud hiervan is:

  • Herhaal je laatste bericht. Stop met het gebruik van jargon en spreek coherent.
  • Formuleer het eenvoudiger en beknopter, zoals één mens tegen een ander praat.

Genoeg is genoeg

Op papier zijn agents intelligenter geworden, maar de ervaring om ze te gebruiken is op dit vlak merkbaar verslechterd. De dingen waar mensen vroeger van hielden bij Claude — de stem, de persoonlijkheid, de "ziel" — zijn weggefilterd in de RL-training (Reinforcement Learning).

Andere modellen zijn iets minder hinderlijk, maar overspoelen ons nog steeds regelmatig met muren van jargon waardoor je ogen dichtvallen. Dit gebeurt tegenwoordig meerdere keren per dag.

Mijn voorstel: show me

We hebben geëxperimenteerd met interne tools om dit te verbeteren, specifiek voor coding, en hebben deze gepubliceerd in een skill die we show-me noemen. Deze is nu beschikbaar in HumanLayer. Als je deze in een andere coding agent wilt gebruiken, kun je hem hier installeren:

npx skills add humanlayer/skills --skill show-me

De inspiratie hiervoor komt mede uit de presentatie van Coda Hale over intuïtie versus aandacht in infrastructurele systemen:

  • Het analyseren van informatie is zwaar en vermoeiend.
  • Je visuele cortex is over miljoenen jaren getraind om rijke visuele informatie moeiteloos te verwerken.
  • Optimaliseer tools naar dienoverride.

Net zoals een bijl in de menselijke hand moet passen om nuttig te zijn, moet software passen bij de menselijke geest.

/show-me spoort de agent aan om beknopte visuals te gebruiken om uit te leggen wat er gebeurt, in plaats van lange teksten. Dit is bijzonder nuttig voor programma-ontwerp — een fase die veel mensen tegenwoordig overslaan, maar die essentieel is. Je zou de vorm van de code (de types, de signatures, de call stacks) moeten bespreken voordat agents aan het schrijven beginnen.

Dezelfde technieken kunnen worden gebruikt om grote diffs achteraf te verkennen, zodat je weet waar je tijdens de review op moet letten.

Wat zit erin?

Component-bomen

Voor de frontend: de state hooks en modulegrenzen die ertoe doen worden behouden, terwijl de rest wordt weggelaten.

<SessionPage> (apps/example/src/routes/session.tsx)
  useSessionEvents()
  <SessionToolbar>
    <RunSkillButton> (packages/ui)

(Zie ook: https://x.com/dexhorthy/status/1998968236617199803)

Call stacks

Voor orchestratie, control-flow of backend-problemen. Dillon bedacht deze "call stack"-vorm:

handleCreateSession
  validateRequest
    SessionStore.insert
      publish(session.created)
        AgentWorker.run
          loadContext
            callModel
              persistResult

(https://x.com/dillonmulroy/status/2059985696148849025)

Tanish heeft zelfs een tool geschreven om deze direct vanuit de AST (Abstract Syntax Tree) te berekenen: https://x.com/tanishqk/status/2085800689129935342.

Diagrammen

Een klassieker. Als je chatinterface inline Mermaid ondersteunt, kunnen deze enorm helpen. Soms zijn ze nog steeds onhandig, maar meestal is het beter dan alleen tekst lezen. We hebben een voorkeur voor toestandsdiagrammen (state diagrams) en sequentiediagrammen.

Bestandsstructuren (File layouts)

Een ondiepe boomstructuur, waarbij elke entry één regel verantwoordelijkheid heeft. Handig voor de vraag "waar staat dit?" en voor het bepalen van de reikwijdte van een refactor.

src/
├── commands/           # parseert acties van gebruikers naar intents
│   ├── registry.ts     # naam -> handler, centrale plek om commando's toe te voegen
│   └── show-me.ts      # breidt het slash-commando uit
├── sessions/           # beheert sessie-status en lifecycle
│   ├── store.ts        # SessionStore - insert / list / open
│   ├── worker.ts       # AgentWorker.run - load context, call model
│   └── events.ts       # publiceert session.created en aanverwanten
├── transport/          # communiceert met de API, weet niets over sessies
│   ├── client.ts       # mapping van request / response
│   └── stream.ts       # SSE decoding, reconnect, backoff
└── config.ts           # env + feature flags

Pseudocode

Vooral voor algoritmische zaken kan pseudocode beknopter zijn:

capture()                                   // alleen als dit oppervlak focus heeft
  target = keyboard focus
  ? focusedBlock
  : firstBlockIntersectingViewportTop
  anchor = wholeBlockAnchor(blocks, target)  // type + tekst + naburige tekst
  offset = targetRect.top - scrollRect.top   // getekend: positie binnen een hoog blok
  publish({ anchor, offset, scrollTop, revision + 1 })

restore(snapshot)                           // na creatie editor + blocks
  placement = resolveAnchor(blocks, snapshot.anchor)
    exact text match
    -> normalized-whitespace match, gescoord op naburige context
    -> 'outdated'
  if resolved
    scrollTop += targetRect.top - scrollRect.top - snapshot.offset
  else
    scrollTop = snapshot.scrollTop           // failure path

Types en signatures

De vorm van de code voordat deze daadwerkelijk bestaat — details die te intern zijn voor een architectuurdocument, maar die een agent nog steeds fout kan begrijpen.

interface Item {
  id: ItemId
  parentId: ItemId | null
  // ...
}

interface Cursor {
  position: ItemId
  direction: 'up' | 'down'
  // ...
}

resolveTarget(items: Item[], cursor: Cursor) -> ItemId | null

Diff-syntaxis

Je kunt ook diff-syntaxis gebruiken als het grootste deel van de inhoud ongewijzigd blijft.

Voor een componentwijziging:

<SessionPage>
  useSessionEvents()
  <SessionToolbar>
+    <RunSkillButton />
  <SessionTimeline>
+    <SkillResultCard />

Voor een wijziging in de call-tree:

handleCreateSession
  validateRequest
+   enforceQuota
  SessionStore.insert
  publish(session.created)
  AgentWorker.run
    loadContext
+     fetchPriorTurns
    callModel
    persistResult
+     emitUsageEvent

Voor een wijziging in de bestandsstructuur:

src/
├── commands/
+│   └── show-me.ts       # breidt het slash-commando uit
├── sessions/
-└── transport.ts
+└── transport/
+    ├── client.ts
+    └── stream.ts

Voor een wijziging in status of control-flow (pseudocode):

on(save)
-  write content
+  if content is unchanged
+    return cached result
+  write new content
+  invalidate cache

HTML Mockups & Diagrammen

HTML heeft voor veel van ons prototypewerk de plek van Figma ingenomen. Soms heb je simpelweg een diagram of uitleg nodig; in HumanLayer laten we de agent direct HTML opnemen in de antwoorden, maar je kunt dit ook gewoon in je browser openen.

Andere inspiratie

Ik wil ook Matt Pocock noemen voor de HTML-uitleggen die worden gegenereerd door zijn /teach skill — zeer goed uitgevoerd.

Probeer het uit

Installeer de skill via: npx skills add humanlayer/skills --skill show-me

Na installatie kun je /show-me aanroepen of de agent vragen de show-me skill te gebruiken. Richt het op een route, service, feature, pull request of het huidige onderwerp. Je kunt het ook gebruiken om het model een vraag of bewering opnieuw te laten formuleren.

Voorbeelden:

  • "Dit is teveel content. show me."
  • "/show-me as an html explainer"