← All speakers

Bio, Work & Ideas

Manuel Odendahl

Conference affiliation: The Tree Center · 2024

Manuel Odendahl is a software engineer, open-source developer, and writer whose work gives programmers more expressive, controllable ways to build with language models. He created the GO GO GOLEMS family of developer tools and argues that AI systems work best when they generate executable code, transform information between useful formats, and leave consequential decisions open to human intervention.

Odendahl’s early work combined embedded programming and electronic music. He developed Mididuino, a framework for programmable MIDI devices, and documented how testing, rapid prototyping, automated builds, and deployment could be adapted to the constrained hardware of the MidiCommand controller. He subsequently worked across back-end development, databases, search, e-commerce, and web applications. His sustained interest in Common Lisp and interactive development shaped his preference for extensible languages and software that can construct its own abstractions.

By March 2023, Odendahl was arguing that language models would change software engineering beyond code completion, influencing architecture, documentation, collaboration, and team workflows. He developed those ideas through GO GO GOLEMS: Geppetto, a Go framework for language-model applications; Pinocchio, a command-line tool for reusable prompting workflows; and Glazed, a framework for structured-data command-line applications. His guide to custom AI command-line tools shows how templates, declarative commands, and project-specific context can turn repeated engineering tasks into reusable utilities. In 2024, he was a principal engineer affiliated with The Tree Center.

  • Language models as translation engines. Odendahl breaks development into transformations between useful representations: meeting transcripts become technical summaries, action items, GitHub issues, and scripts; existing code becomes documentation, onboarding material, or targeted context. Each intermediate artifact remains inspectable and useful to people.
  • Domain-specific languages for sharper context. He uses compact, purpose-built formats to expose the structure models need: network captures can become YAML descriptions of relevant traffic, while large repositories can be reduced to function signatures, documentation, and selected interfaces. His AI-assisted programming workshop also shows how simulated application interfaces and adversarial fictional code reviews can uncover requirements and security problems before implementation.
  • Executable code over rigid tool calling. Odendahl argues that predefined agent tools can proliferate unnecessarily, repeat existing context, and return oversized results. In his critique of conventional MCP integrations, a Go-hosted JavaScript sandbox with SQLite and a web-server interface lets a model inspect schemas, filter data, save reusable functions, register REST endpoints, and assemble an interactive CRM.
  • Human-editable agent interactions. He advocates interfaces that let users correct tool arguments, trim returned data, adjust filters, and rerun individual operations. Those controls preserve human judgment while avoiding expensive, opaque agent workflows that offer only approval or rejection.

Read the topics behind these talks

2 conference talks

Key ideas

Scroll to read ↓

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.

  • What can you hand to the model today?
    0:19 ↗
  • Regenerate, edit, and start fresh
    5:25 ↗
  • Remove friction and preserve the useful result
    7:34 ↗
  • A T-Rex makes the abstraction visible
    9:35 ↗
  • Language carries more than instructions
    25:42 ↗
  • Turn a meeting into decisions, then tickets
    29:38 ↗
  • Give ordinary software a representation it can consume
    33:47 ↗
  • Tailor the explanation to the developer
    36:11 ↗
  • Choose the intermediate artifact
    37:42 ↗
  • Translate large inputs into useful context
    48:53 ↗
  • Give the review a reason to disagree
    52:28 ↗
  • Simulate the conversation you wish you had started
    56:49 ↗
  • Assemble fresh context with small tools
    1:02:56 ↗
  • Know when generation has stopped helping
    1:06:07 ↗
  • The remaining work is choosing what to build
    1:10:25 ↗

Key ideas

Scroll to read ↓

A weather lookup, a CRM query and a JavaScript sandbox show how generated code can reduce model round trips and turn one-off answers into reusable software.

  • What happens when you ask for the weather?
    0:01 ↗
  • The model becomes a data courier
    3:19 ↗
  • One email address, an entire CRM response
    5:47 ↗
  • Let tools use context the application already has
    7:25 ↗
  • Approval should not be the only intervention
    9:28 ↗
  • Ask for the code that performs the action
    12:05 ↗
  • Discover the schema, then let SQL count
    16:18 ↗
  • Keep the useful code
    18:04 ↗
  • Generate an interface for the person, too
    20:57 ↗
  • A JavaScript evaluator with a database and a server
    22:47 ↗
  • From a query to a usable CRM
    24:59 ↗
  • Code that creates the next capability
    26:48 ↗

References