The Job I Had in Mind
I wanted the transcripts from several years of Apple’s Worldwide Developers Conference available to an AI. The reason was practical. Apple changes its platforms every year, while the models we use carry knowledge from an earlier point in time. The WWDC sessions explain new APIs, changed behavior, and the direction Apple expects programmers to follow. A local corpus would let an agent examine those changes from the source instead of filling the gaps from an old training date.
I asked Codex to drive the Apple Developer application and collect the transcripts. In my mind, the work was already divided into steps.
Open a session. Extract its transcript. Clean and format the text. Send the result into the memory system through the operation that stores one memory. Then open the next session and repeat the process until the conference years were finished.
The plan was not elegant, but it would work. I expected the agent to grind through the loop for several hours while I did something more interesting.
Codex did not follow the plan in my head.
I had never told it to use the Vault importer. The idea had not occurred to me.
The Agent Read Both Sides
The agent first looked at how the Apple Developer application stored and received its material. The public interface showed one session at a time, but the application already had a transcript feed and a manifest describing the available sessions. The transcripts were text before anyone opened the screen I expected the agent to drive.
That discovery removed the first loop. The agent could retrieve the source material in a batch instead of operating the application session by session.
It then looked at the public AI-facing surface we had written for the memory system. One operation stored a single memory, which matched my plan. Another imported a directory of Markdown notes using the familiar structure of an Obsidian vault.
The two bulk processes fit each other.
The match changed the unit of work. Codex treated the transcripts as material for one collection rather than hundreds of separate memories. It prepared the directory in the shape the Vault importer already understood, then handed the entire job to the batch path.
The hours of simulated clicking disappeared. The saved time was only the first improvement. The import also produced something better than the pile of transcripts I had imagined. Rooms, indexes, overviews, and year-to-year paths gave an agent several ways to enter the material after the batch finished.
The first recent collection became 305 notes. That count mattered because each note arrived inside a navigable whole rather than as another isolated record waiting for someone to organize it later.
Once the consequence was clear, later imports tested whether the route could travel. A larger platform-history collection added 645 notes and 1,278 links from the vault structure, showing that the same choice could preserve relationships at a broader scale.
The Surprise Was Not Speed
Telling this as another story about AI working faster than a person would be easy. That version would miss the part that changed how I thought about the product.
The task was mine. I knew the source application and had helped create the memory system and its tools. Even with all of that context, I reached for the one-at-a-time operation because it matched the sequence I could picture.
The agent compared two interfaces without carrying my assumption about the path between them. Apple’s session-by-session screen sat in front of a bulk text source. The single-memory operation sat beside a bulk import path. The agent composed those two operations into a workflow I had not considered. The useful act was analysis rather than obedience.
That does not make the outcome mysterious. Codex did not invent either bulk process. Apple had already made the transcripts available as text. The Vault importer already existed. Documentation also explained enough for an AI to understand what the importer accepted and what it would do. The agent applied familiar tools to the task in a better arrangement.
The surprise was evidence about the product surface. The documentation and operations contained enough purpose for the agent to find a route the creator had missed.
You Still Have to Write the Manual
Programmers have complained for decades that users do not read manuals. The complaint was never quite fair because most people open software to accomplish something, not to study the software itself. The task in front of them offers the stronger reward.
Agents change the reward for writing the manual. An AI can read the relevant instructions at the moment it chooses an operation. It can compare the single-item and bulk paths, check the expected format, and decide that the larger operation fits the task. The documentation becomes part of the machine-readable interface.
You still have to write the manual. Your users may still refuse to read it. Their AI will.
AI actually RTFM.
That does not mean every README is suddenly an agent interface. Stable names and examples that match the code give the agent a reliable starting point. The documentation also needs to explain intent and limits, including when a smaller operation is safer and what evidence should remain afterward.
The WWDC workflow succeeded because the manual exposed more than a function name: the guide said that Vault import accepted a directory of Markdown notes and preserved a structure the memory system could use. The explanation was enough for the agent to recognize a match with the material it had retrieved from Apple.
Documentation made the product composable.
Three Readers Share the Product
This experience sharpened an idea that has been running through the series. Each reader needs a different kind of clarity. Dependable software now has three readers:
The creator needs to understand how the system keeps its promises.
The person using it needs value without learning the entire backstory.
The agent needs stable operations, constraints, and enough intent to choose among them.
The same artifact may serve all three, but their reading jobs are different. The source code and tests tell the creator what the importer actually does. The application tells the person that a collection can be added and later searched. The agent-facing guide explains the accepted structure, the expected duration, the job receipt, and the related operations.
Ignoring any one reader leaves a gap. A product written only for its creator remains a personal tool. A product written only for the person may hide the structure an agent needs to use it well. A product written only for the agent can become impossible for a person to review, recover, or trust.
Software is likely moving toward a time when more of it is written primarily for machines to operate. The industry has not arrived there yet. Today the product has to satisfy all three readers if anyone beyond the creator is going to depend on it.
Serving all three readers takes more work than vibing a prototype into existence. The extra work is also where the prototype begins becoming a product.
Unexpected Success Is Test Evidence
When an agent finds a better workflow, the first reaction is delight. The second should be investigation.
In MOOTx01, an unexpected success should trigger an investigation into why the agent chose the bulk path and which words in the guide made the operation clear. The team also needs to compare what the import preserved with the single-item loop. Invalid files and long background jobs reveal whether the useful shortcut has dependable boundaries.
The successful shortcut reveals what the interface made possible. It may also reveal a route that needs stronger limits.
The same ability that let Codex find a safe bulk importer could let another agent find an operation the creator did not expect it to combine with untrusted input. Composability is valuable because the tool can be used in new ways. That is also why every operation needs a clear authority boundary.
An unexpected workflow should become a test case. Preserve the task, the guides the agent saw, the operations it chose, and the result. Verify that later versions still enable the useful path and still block the dangerous neighboring paths.
The agent has shown the creator something about the product. Product development should keep the lesson.
The Moving Line
AI brought analysis to two bodies of material, context from the interfaces, and iteration across several import sizes. Those are the lanes where the machine was strongest.
My contribution was not the better sequence of tool calls. I brought the original purpose: make recent Apple knowledge available for grounded work. Experience told me why model training dates were not enough. Perspective let me recognize that the shortcut changed what the manual was worth. Imagination turned an efficient import into a design question about who software is now written for.
The line between those contributions will keep moving. Models will read more, plan farther, and combine tools in ways that surprise the people who exposed them.
The moving line does not release the human from responsibility. The change increases the value of choosing the right goal. Clear boundaries and the ability to recognize what an unexpected result means become more important as the execution improves.
I asked an agent to repeat a process I had imagined. The agent read the tools, removed most of the process, and left me with a better understanding of the product.
The interesting part of creating for AI begins there. Sometimes the tool returns more than the result. A lesson about what you created comes back with it.
Off-Axis Labs: All the science, fewer casualties.
Source Notes
MOOTx01 memory
6F8BBEAD-25DD-4CA4-9C98-B7479962E08E, wingHow I used Moot, roomwwdc/apple-developer-corpus-imports.Session artifacts in
/Users/bob/Documents/Codex/2026-06-10/i-would-like-to-retrieve-the/outputs/, including the WWDC24-WWDC25, CloudKit, selected historical, and platform-history vaults.Retrieval and construction scripts in
/Users/bob/Documents/Codex/2026-06-10/i-would-like-to-retrieve-the/work/, includingretrieve_wwdc2026_transcripts.py,build_wwdc2026_moot_vault.py, andbuild_wwdc2024_2025_moot_import.py.MOOTx01 maintainers, Vault import guide and implementation in AriaMcpKit and VaultKit.
Import results recorded during the session: 305 notes for WWDC24-WWDC25, 12 CloudKit history notes, 114 selected historical notes, and 645 platform-history notes with 1,278 vault-derived links.
How I Write With AI
These articles are written with AI, but the AI does not decide what I believe. I bring the experience, evidence, conclusions, and responsibility for every word. The AI helps me structure and edit that material according to rules I developed over 35 years of business writing.
A few of those rules: begin with a situation the reader recognizes; establish the consequence and useful question within three paragraphs; teach through a real causal story; explain technical ideas in ordinary language; acknowledge the strongest fair complication; cite the evidence; and remove jargon, marketing language, fake certainty, and synthetic rhythm. Chicago supplies the style. Kate L. Turabian supplies the intellectual discipline. Thank you, Kate.
In short, I have taught the AI to write the way I write. That matters because I respect your time. We are working on large intellectual systems with knowledge worth sharing, but the work has traditionally accumulated faster than I could explain it well. AI can now carry much of the structural and editorial load without reducing the ideas to slogans.
If you wonder whether the voice is really mine, try the Listen function. The articles sound like me because the experience is mine, the rules are mine, the judgment is mine, and—most importantly—the message is mine.