AI Engineer World's Fair 2024
LLMs for the working programmer. Become a 10x programming centaur today!
Loading slides…
Read the talk
LLMs for the working programmer. Become a 10x programming centaur today!
From a T-Rex operating system to meeting-derived tickets and simulated applications, Manuel Odendahl shows how small, inspectable language transformations can support everyday programming.
From a talk by Manuel Odendahl
Before you start: Basic programming experience and access to an LLM chat interface are enough to follow the workshop; the examples span shell scripting, Python, PHP, Go, and YAML.
What can you hand to the model today?
How do you put an LLM to work on ordinary programming: e-commerce, PHP, and the tasks already on your desk? Manuel Odendahl approaches that question after twenty-five years of professional development. His workshop’s ambitious 10x framing begins with a modest setup: a chat interface, such as OpenAI’s or Claude Sonnet, is enough. A local model or Phind can also serve; there is no required checkout or Git fork. Participants work with neighbors, using prompts from the workshop repository and its PDF handout, with Slack as the shared question channel.
Treat the model as a translation engine. Programmers already translate GitHub tickets into code, then translate broken code back into tickets. An LLM offers more routes between these representations. The workshop moves from concrete interaction techniques into translation workflows, then into the more experimental idea of simulating a world or application through text. The handout prompts are starting points for experimentation, not guaranteed sequences: try a transformation, inspect what appeared, and choose the next step.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Regenerate, edit, and start fresh
A first response can produce either delight or dismissal: the code looks excellent, or it contains a bug and the tool seems useless. Regeneration exposes more of the model’s behavior. Odendahl illustrates this with ten attempts: three working answers, five nearly working answers, and two that go off course. Those numbers describe a possible distribution, not a measured success rate. He also observes that ChatGPT’s regenerations had become less varied, and suggests API temperature control when more variation is useful.
The next intervention changes the history rather than adding another argument to it. If an assistant produces bad code, correct that code in its previous message where the interface permits it. Future generation then sees the corrected version as the assistant’s earlier output. Odendahl names LM Studio and LibreChat as interfaces for this workflow; the controls he describes belong to the workshop-era interfaces. The linked LM Studio release notes postdate the workshop.
He also usually carries the latest useful output into a fresh conversation after three or four prompts. The purpose is to make the context understandable again: a long chat can contain abandoned approaches, corrections, and uncertain summarization. He qualifies this habit as less necessary with larger models. Trying different models—including smaller ones that need more guidance—builds practical intuition about which transformations each can handle. Practice matters, but it can itself become a distraction when writing the task prompt turns into writing a prompt that generates the task prompt.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Remove friction and preserve the useful result
A session-specific system prompt saves repeated explanation. For a day of PHP work, include the libraries and formatting conventions you actually use; change that prompt when the work changes. The same opportunistic approach applies to tooling. If generated code arrives with imports you must remove before pasting into an existing file, ask for a clipboard helper. It can open the clipboard in an editor or strip the unwanted lines. Keep the helper if it remains useful, or discard it when the task ends.
For example, a macOS shell helper can make the clipboard editable without building a larger application:
bash
#!/usr/bin/env bash
set -euo pipefail
scratch=$(mktemp)
trap 'rm -f "$scratch"' EXIT
pbpaste > "$scratch"
"${EDITOR:-vi}" "$scratch"
pbcopy < "$scratch"
The helper addresses one repeated interruption: moving text through an editor and back to the clipboard. Its value does not depend on becoming a permanent tool.
Summarize the exploration into an artifact someone can use. A README, how-to, wiki entry, or RFC gives a colleague a clean document instead of a long conversation. Even a debugging rabbit hole can produce a useful handoff: what caused the TypeScript problem, how it was resolved, and which links supported the investigation. The workshop repeatedly asks participants to share these summaries with their neighbors. The resulting document preserves the useful path without requiring anyone to read the equivalent of a search history.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A T-Rex makes the abstraction visible
Infrastructure examples can bury their own structure in overlapping vocabulary: a script that creates scripts, or a system that manages functions that manage systems. Odendahl uses conspicuously different domains to separate the content from the machinery. Dinosaurs, zoo animals, or Tolstoy provide names that cannot easily be confused with kernel terminology. His concrete example is an Arduino real-time operating system for a remote-controlled T-Rex. The first goal is to expose concepts worth investigating, rather than assume the generated system already works.
The live prompt mixes real-time preemption with prey hunting. When the result contains prey-detection tasks, the distinction becomes visible: prey detection is the task’s domain meaning; the task mechanism belongs to the RTOS. The generated answer initially uses FreeRTOS. Odendahl rejects that choice and asks for an RTOS implemented from scratch. That second output becomes a technical sketch whose unfamiliar parts can be investigated and whose boilerplate can be replaced.
A known timer-interrupt implementation provides a stronger correction than a vague instruction to improve the code. Replace the generated interrupt with your implementation in the assistant’s response, then regenerate so the continuation can follow the demonstrated pattern. Odendahl describes this as a short interaction sequence: supply the concrete pattern, then let the model extend it.
The final transformation turns the exploration into documentation: request a README for colleagues, then ask for examples and caveats while outputting only the new text. The displayed artifact includes caveats about error handling, timing, power management, testing, and platform dependencies. A participant suggests another representation—Mermaid charts rendered in artifacts—to explain the code visually. Odendahl’s broader habit is to type the action being discussed directly into the model: the spoken idea becomes the next request.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Language carries more than instructions
Odendahl calls LLMs a cultural technology: no individual can read and understand everything represented in their training material, so practical use involves probing patterns drawn from human language and culture. This is his working explanation of the technology. Natural language, code, mathematical notation, and structured data all become tokens in the same generation process.
That perspective changes the value of names. A variable named year_over_year_revenue carries financial meaning that A does not. In Odendahl’s account, this gives the model more useful associations when generating the surrounding code. Theater, poetry, marketing literature, textbooks, and mathematical formulas can likewise shape the response. For code review, he proposes a theatrical argument among reviewers: the conflict supplies a structure for challenging code that a polite, generic review may lack.
The engineering task becomes choosing a sequence of representations:
| Translation | What changes |
|---|---|
| Informal request → formal description | Intent becomes explicit structure |
| Domain description → code | Domain concepts acquire executable machinery |
| One domain → another | A familiar pattern gains a different vocabulary |
Once a representation is formal enough, ordinary software can interpret it. The T-Rex and RTOS example mixes two domains; a JSON response crosses into a machine-readable format. Odendahl even offers career-related encouragement as an example of culturally framed prompting for JSON. The practical question is whether each step is small and clear enough for the selected model to perform.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn a meeting into decisions, then tickets
A planning transcript is an especially useful test of translation design. People interrupt, use shorthand, and revisit earlier points. Odendahl imagines twenty-eight pages of this material: asking for everything in one response makes topic coverage, technical detail, and assignment extraction compete with one another. He finds Claude useful for first identifying the topics, then uses those topics to direct subsequent passes through the original transcript.
The workflow preserves access to the source at each important step:
- Identify topics. Produce a short topic list rather than a detailed account of every decision.
- Recover details by topic. Return to the transcript for each topic and extract what was actually discussed.
- Extract action points. Use the details and transcript to determine who committed to what. Enrique taking a task and Sarah suggesting an option are different kinds of information.
- Draft issues. Combine action points, technical details, and relevant code into tickets with implementation plans, assignees, tags, and the team’s naming conventions.
Each intermediate output gives the next request a narrower target. The topic summary directs attention; it does not replace the transcript as the source of details.
This can remain a manual workflow. Paste the artifacts between requests and intervene when the result drifts—for example, ask specifically what Enrique said about a point you remember. Odendahl uses small scripts to help assemble prompts, but does not require an agent framework to coordinate these stages.
The same meeting material can become a refactoring proposal. Supply the existing documentation, code, and exact function names; ask for the API rename mapping, then a script to perform it. Add the team’s RFC guidelines to turn the technical decisions into a reviewable document. A test branch can hold the proposed refactoring alongside the RFC. Once colleagues comment, feed their comments back with the RFC and technical summary to revise the proposal.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give ordinary software a representation it can consume
Once the issue drafts exist, request them as YAML. Fields such as title, tags, assignee, ticket number, and link turn the prose into a representation a program can consume. A draft might have this shape:
yaml
issues:
- title: "Document the API rename plan"
tags:
- refactoring
assignee: enrique
ticket_number: null
link: null
Here the ticket number and link remain empty because this is proposed issue data, before creation. The next translation is a script that reads the YAML and calls the GitHub API. When generated API usage is wrong, Odendahl supplies the API documentation as context.
Build the tool incrementally: help text, a README, flags, confirmation, and packaging can each be a separate request. Even creating package.json from an existing JavaScript utility is a small translation that removes tedious work. Colors and emojis are optional finishing touches, not prerequisites for the first working path. Odendahl’s quick-script discussion is an estimate of what generation might produce, rather than a demonstrated API execution.
Inspect the YAML before creating the issues. The structured artifact gives the team a place to review assignments, wording, and proposed work before an external operation occurs. Once that path is useful, combine the script with Slack bot API documentation to notify the developers assigned to the tickets. The workflow has grown from manually translated meeting notes into a possible integration without changing its underlying stages.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Tailor the explanation to the developer
Integration setup can still be the awkward part: Slack tokens and OAuth may interrupt an otherwise straightforward workflow. Odendahl suggests asking for setup assistance, such as a token-acquisition script or the relevant setup destination. He then adds another input to the issue-generation process: a text file containing each developer’s preferences.
The file can describe background knowledge, unfamiliar libraries, preferred presentation, and the area of the codebase currently occupying that developer. Inject it when generating their assigned work. An intern’s ticket might explain the HTTP concepts involved; another developer might need the internal deployment procedure. An onboarding document describing the architecture can provide shared context, while the ticket connects that architecture to a specific task.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose the intermediate artifact
An API client can begin with observed traffic rather than a prose specification. Odendahl describes recording browser interactions, cleaning up the HTTP capture, asking for documentation of the requests, then using that documentation to request a proxy. His example involves the Claude web interface, and he explicitly describes it as usage the provider does not want; it is an unofficial interface example, not an officially supported integration. The useful transformation is capture → documentation → implementation.
Learning can follow a similarly staged path. Start with search results, existing knowledge, codebase context, and preferences, then generate a personal wiki entry. For advanced TypeScript lambda material, a Ruby background can shape explanations, exercises, and project ideas. Company guidelines can make those exercises teach local conventions at the same time. Build a prototype, then supply the actual API to move toward an implementation. The wiki entry and exercises remain useful artifacts along the way; a colleague with a Lisp background can receive an adapted version.
Sometimes the useful intermediate language does not exist yet. A domain-specific language, or DSL, gives a particular task its own vocabulary and structure. Ask for a language for writing reports, then ask for its interpreter. Odendahl’s workshop example is an Alien-inspired text adventure: the game description and the machinery that interprets it become separate targets. Self-contained HTML and JavaScript, with a chosen library when needed, are another convenient destination. The exercise is to replace the domain in a request to create a YAML DSL and see which representation makes the intended program easiest to describe.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Translate large inputs into useful context
An audience question about PCAP files makes the representation problem concrete. Odendahl has not found direct handling especially useful, so he introduces a conversion step: invent a YAML DSL for interesting DNS traffic, then generate a Python program that reads PCAP and emits that YAML. Names such as DNS traffic and destination IP expose meaning that byte offsets do not. The result is intended to become prompt context or input to a larger loop; the demonstration shows generation, without an execution result.
A second question asks what it means to put a huge codebase into a prompt. Humans rarely read the whole repository at once: they inspect a relevant region, its API, and its documentation. Odendahl asks for a YAML language that selects Python functions, classes, and docstrings. He likes the generated recursion option, adds Markdown extraction, and then asks for the implementation. The intended output is a compact inventory of function names, docstrings, and document titles. He distinguishes the quickly generated sketch from the additional work of adding a README, tests, examples, and an installable package.
A small Python extractor illustrates the structural part of that approach. It parses definitions instead of sending entire files to the model:
python
import argparse
import ast
from pathlib import Path
import yaml
def collect(root: Path) -> list[dict]:
records = []
for path in sorted(root.rglob("*.py")):
source = path.read_text(encoding="utf-8")
tree = ast.parse(source, filename=str(path))
for node in ast.walk(tree):
if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
records.append({
"file": str(path.relative_to(root)),
"line": node.lineno,
"kind": type(node).__name__,
"name": node.name,
"docstring": ast.get_docstring(node),
})
for path in sorted(root.rglob("*.md")):
headings = [
line.strip()
for line in path.read_text(encoding="utf-8").splitlines()
if line.startswith("# ")
]
records.append({
"file": str(path.relative_to(root)),
"kind": "markdown",
"titles": headings,
})
return records
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("root", type=Path)
args = parser.parse_args()
print(yaml.safe_dump(collect(args.root), sort_keys=False))
This version uses PyYAML and recursive traversal. It supplies a structural index, not function bodies or a complete description of behavior; the task determines what additional context to retrieve.
These extractors become reusable context fragments. For a new widget, collect related widget implementations and documentation. Translate recent Git history into a how-to, then include it in later prompts. Rerun the collection script so the context reflects the current codebase, and generate the new widget in stages, beginning with its props. The same method can produce task-specific documentation from a third-party library’s source when its existing docs are inadequate. Odendahl notes that this work can be quick, but it can also turn into a day-long diversion.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the review a reason to disagree
The next technique treats a prompt as the premise of a simulated world. Ask for a wizard, poetry, or a world where time travel exists, and the model can continue within that premise. Odendahl applies this to code review with Code Survivor, a reality show whose contestants are variables and functions. They attack one another, identify defects, and vote out the buggiest participant. The fictional setting gives disagreement an explicit role in the output.
He generates bad PHP and pastes it into a custom GPT with that format. Each contestant gets a turn to attack another and identify a conflict. Odendahl emphasizes the framing over exact prompt wording; he reserves more careful prompt refinement for repeated operations with smaller models. He reports that asking for multiple rounds helped older ChatGPT produce sustained, concrete criticism in one response, rather than an agreeable review or an instruction to fill in the rest. Additional contributions can appear as a returning contestant.
A contestant need not be a literal code object. SQL injection can become a character with its own personality and accusations. The generated discussion also suggests calling mysqli_close after database use. That is a suggestion to assess against the program’s lifetime, not automatically a bug: PHP cleans up non-persistent connections automatically, while explicit early closure can help when substantial processing remains. The API does not close persistent connections.
The theatrical output is an intermediate artifact. Once the participants have argued, request a sober code-review report that strips out the reality-show language, retains the concrete findings, and suggests fixes. Those findings can then become GitHub issues. The useful pipeline is code → conflicting critiques → ordinary review, with the fictional format helping generate material for the final technical document.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Simulate the conversation you wish you had started
A correction-heavy conversation can also be rewritten through a fictional premise. After a long sequence finally reaches satisfactory code, summarize what worked. Rewind to the beginning and supply that summary as advice from the model’s future self. Odendahl attributes the usefulness of this framing to the familiar time-travel story: the new context contains the successful guidance without requiring the model to work through every rejected attempt again. Presidential debates and Greek drama offer other formats for organizing disagreement.
The more radical request is to have the model act as the application before implementing it. Ask it to start, describe its UI in a concise DSL, and respond to interactions. You can request a sidebar, then say that you clicked its third element. The model continues the imagined application state through text.
The live example is a family flight, travel, and sightseeing planner. Odendahl asks for the UI in YAML, but the initial answer is too focused on the application’s data. He corrects it toward actual widgets—an HTML-like markup representation, or React components if preferred. He then asks to open the day-two tab. The model can invent tabs that were not previously specified, so this interaction explores possible behavior rather than demonstrating an already implemented UI.
A proposed JavaScript renderer could parse the DSL and return button events as text. After exploring the interactions, ask for a concise README-style specification, then an implementation. Odendahl describes this as a new technique he had only recently begun exploring. His film-development example starts with timers for chemical stages, changes to parallel looping timers, and ends with a self-contained HTML/JavaScript prototype. The prototype and transcript provide a handoff: a designer can explore behavior, then a developer can turn that exploration into a real application.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Assemble fresh context with small tools
Once these workflows produce many useful fragments, finding them becomes a practical problem. Odendahl wants searchable, tagged histories, but his own solution centers on files and scripts. He describes Prompto as a personal, once-generated hundred-line script that scans configured repository directories and lists text files, executable scripts, and YAML templates. His workshop version lacks pagination, indexing, and caching, and he discourages treating his frequently changed tool as the standard to adopt. The current repository has evolved beyond that historical implementation.
The parameter-context example concerns Glazed, the Go framework associated with the glaze executable. A context lookup retrieves parameter documentation or output extracted from Go source. Fragments are joined with --- and passed to a simple command-line LLM client; the assembled prompt can also be printed for inspection. The important operation is visible concatenation of relevant source material, not a sophisticated retrieval system.
The task is to create a URL parameter in Go using the supplied API context. During inspection, Odendahl notices that the system prompt accidentally describes a PHP developer. He nevertheless expects the concrete Go context to guide the result toward the right packages and API usage. Follow-up scripts can integrate the prototype into the framework and apply his documentation conventions. The demonstration concerns the parameter API used in the recording; it does not require substituting the project’s current API or assuming that the generated code has run.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Know when generation has stopped helping
Odendahl reports generating six or seven decent programs during the workshop, while acknowledging that they may not work well. Adding tests and polishing them is subsequent work. His stopping rule is practical: if the approach is not producing progress within about ten minutes, stop forcing it. Write the code manually, or take a walk and reconsider which translation step the model failed to understand. Otherwise, generating helpers that do not work can replace the original task entirely.
Generation also creates an attention problem. Odendahl describes being unable to mentally manage all the programs he produces, even with an experimental repository available. He has forgotten large generated tools and written them again, including customer-management software for Shopper Approved with parallel work queues. A growing quantity of code is not automatically a growing quantity of usable capability.
Fundamental and practical knowledge still determines whether you can steer the work. Knowing how an RTOS operates makes it possible to reject an unsuitable assembly implementation or choose a better pattern. Without that knowledge, a plausible-looking answer can send the whole exercise into a dead end. Odendahl distinguishes this understanding from memorizing API details: he wants to retain deployment patterns such as infrastructure as code and functions as a service, while delegating the tedious particulars of CloudFormation. Those patterns transfer across DigitalOcean, Amazon, and Google; checking an IAM rule remains part of making a deployment work.
Human usefulness is the criterion for the artifacts too. An output either directly helps someone or helps the model reach something that does. A README can serve both audiences because the model works with human language. Conversely, generic paragraphs about error handling may add little for senior colleagues. Removing them produces a more focused document and a smaller prompt. Choose the decomposition by asking what the user needs to accomplish and what information would help a person do it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The remaining work is choosing what to build
Divergent thinking broadens the set of transformations available. Odendahl calls Code Survivor his best discovered review prompt, but does not present a comparative evaluation. He recommends looking at how nonprogrammers prompt: a premise such as an alien writing code may uncover a useful approach that a programmer would never think to try. His contrast is between rejecting generated work over a missing loop check and continuing toward an application that serves a concrete purpose, such as filming a daughter. The useful skill is exploring an unexpected framing while retaining the ability to judge its output.
Abstract thinking then asks whether to build the thing, the thing that builds it, or a better language for describing it. Odendahl points to Common Lisp, Ruby, and Haskell communities as sources of ideas about compilers, dynamic-dispatch DSLs, and mathematical approaches to control flow. Adopting those languages is optional; understanding their ways of forming abstractions is the point. Language design also includes documentation. His preferred format—title, one sentence, code example—is a small language for communicating an idea clearly.
The closing questions expose an unresolved organizational problem. Does rapid prototyping make him the person who incubates ideas before the rest of a team builds the actual product? Odendahl had recently joined a team after working largely alone, and says he does not yet know how to bring colleagues into a workflow that produces and discards large amounts of code. The personal techniques do not by themselves settle ownership, handoff, or how a team should absorb the output.
Asked about Auto-GPT-style systems, his answer is that he does not use them. The demonstrated practice consists of individual zero-shot requests through chat or an API, with the programmer inspecting the result and selecting the next transformation. He also uses Copilot in its ordinary role, which he considers a different kind of tool. The unresolved challenge is how to turn that individual fluency into work other people can understand, maintain, and build upon.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Companion repository containing the workshop handout, preparation notes, and further reading.
A command-line tool that assembles prompt context from documentation and executable scripts across configured repositories. Use only trusted repositories.
A Go framework for command-line applications with structured output, reusable configuration fields, and integrated documentation.
An open-source chat interface supporting multiple model providers, editable messages, and conversation branching.
Reference for mysqli_close, including automatic cleanup, optional explicit closure, and persistent-connection behavior.
Updates since the talk
September 2024 release notes explaining saved system prompts and inference settings, chat cloning, and message-editing controls.
Full transcript
Loading transcript…