LLMs & Jo-Ha-Kyu

The Before Times

Think back to the before times. LLM for all you know is just the initials of some obscure celebrity.

The experience of coding feels like:

1: You start. The page is blank & the directory is empty. You have ideas but you don’t know exactly what you’re doing or what it will look like.

2: You work. This involves slowly building up files. Researching syntax as you go. Learning as you go. Your understanding builds as your line count grows. Maybe not exactly one-to-one, but both start from zero and mostly grow linearly.

3: You have a ‘finished’ product. And you understand mostly how you got there. You have to understand. These are the before times. If you hadn’t understood, you wouldn’t have gotten there!

Coding with LLMs

The experience of coding feels like:

1: You start. You articulate what you want, press a few buttons, and

3: You have a ‘finished’ product. Neat!

2: You work. You actually read the code. You make a small manual change and see if it does what you expected. You tell the LLM to change something. You ask the LLM what the heck is going on with some file you don’t understand and the LLM cheerfully thanks you for catching its mistake, that file isn’t actually necessary at all. You keep working. Keep reading. Rewrite small and large sections. Have the LLM refactor things. Have the LLM refactor its own refactor. You realize something went wrong so you jump back to a previous checkpoint and then repeat some prompts but slightly differently. This part is a lot of work.

Hot take: its not that different but also very different

The biggest difference between LLM-coding and Before-Times-coding is where the majority of the work falls. Before-Times-coding most of your work is actually building the thing. LLM-coding most of the work is re-building the thing. And you don’t rebuild the thing necessarily because the LLM did it wrong (though often the LLM did it wrong). You rebuild the thing because you have to to understand it.

Jo-Ha-Kyu

https://en.wikipedia.org/wiki/Jo-ha-ky%C5%AB

(However qualified I am to talk about coding (not very), I’m even less qualified to talk about Jo-Ha-Kyu.

I was exposed to it via instructors I had (affiliated with Portland (OR) Experimental Theatre Company) who themselves I think got it from studying with the SITI company, which is partnered/affiliated with the Suzuki method. I might be wrong about the chain of custody/lineage. But Jo-Ha-Kyu is a thing, from Japanese theatre and art generally.

I am not qualified to explain it, and really truly don’t completely understand it.

I have an understanding of what I think it kinda means that … generously you could maybe say is like the Kroger-brand version of it. But less generously maybe I just don’t understand. But anyways enough preambling… )

Two ways to think about narrative structure

Before-Times / Traditional Narrative Structure

You can think of a story/narrative as structured around an Event/Action. Something Happens. The person who performed the Action is obviously the Protagonist. And a Story is then just:

1: Before The Action (build up/exposition/rising action/whatever)

2: The Action (climax!)

3: After The Action (resolution)

I think of this as roughly analogous to Before Times Coding. As the Coder you are the Person Doing The Action, the protagonist. You have Total Agency. You Understand Everything You Have Written. Look At You! Well done. Steve Ballmer sees you, and appreciates your works.

LLM-coding / Jo-Ha-Kyu Structure

Another way of thinking about a story/narrative could be to structure around something other than an Event/Action. Like, say, the revelation of some nugget of information (example that comes to mind right now because its in the news as I write this: when the Try Guys Wife Guy was revealed to be a cheater).

You can still have three ‘sections’ of the story:

1: Before the Information Nugget (in our example: Ned is a cheater) is revealed

2: Information Nugget comes to light!

3: Things that happen after Information Nugget comes to light (Or alternately: we re-examine things, but now in light of Information Nugget the narrative has changed)

I think of this as roughly analogous to LLM-coding. As the coder you invoke a quasi-magical incantation and summon 100-1000 lines of code into the world. You then must work to understand what even is going on. You are not the protagonist. You are just trying to understand and then use that understanding to shape things.