# Claude Code Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/claude-code
> Markdown URL: https://aitinkerers.org/technologies/claude-code.md
> Technology record last updated: 2026-09-18T15:14:01Z
> Generated: 2026-09-21T02:40:46Z

Anthropic's agentic coding tool: Unleash Claude's raw power directly in your terminal or IDE to turn complex, hours-long workflows into a single command.

Claude Code is Anthropic’s powerful agentic coding assistant, designed for high-velocity development. It operates natively within your terminal, IDE (VS Code, JetBrains), or via a web interface, allowing you to delegate complex tasks like feature building, bug fixing, and codebase navigation. The agent plans, edits files, executes commands, and creates commits, maintaining awareness of your entire project structure. Internally, Anthropic engineers using Claude Code reported a 67% increase in productivity, demonstrating its capacity to deliver significant gains for Pro and Max plan users.

- Official technology site: https://claude.com/code
- Public AI Tinkerers demos and talks: 215
- Result page: 1 of 9

## Recent Public Talks and Demos

### [durable agent orchestration - or how i learned to stop worrying and love the waterfall](https://dubai.aitinkerers.org/talks/rsvp_gUMEdXOl6G4)

This demo showcases how we can improve one of the main issues with agentic coding: non-determinism, and loss of planning context and tasks due to context rot in complex projects. By using beads (https://github.com/gastownhall/beads) to track complex task planning in combination with prescriptive communication protocols and handover, we can not only keep a durable persistent state across multiple agent sessions in the same project, we also now have a consistent agent-agent communication protocol across coding agents, orchestrators, watchdogs, and dedicated task runners. In this demo we will demonstrate how beads works in conjuction with coding agents, an overview of its capabilities, and how it can drive autonomous agentic development work for multi-day goal runs. This is a showcase of how to use beads across various automation levels, including agent orchestration, spec driven development, as well as to create repeatable consistent plans that can be used by agentic tools

- Event context: AI Tinkerers Dubai - October Demo Day — 2026-10-10 — Dubai
- Public talk page: https://dubai.aitinkerers.org/talks/rsvp_gUMEdXOl6G4

### [A Self-Improving AI OS for the Chronically Self-Employed](https://barcelona.aitinkerers.org/talks/rsvp_AA_yQ6WeHtc)

A personal AI operating system, built as a plain-text git repo, that connects to my entire freelance business in real time: live contracts, open invoices, job feed, inbox, calendar, and meeting notes. It uses that context to find work, draft proposals, track clients, and run a morning brief every day without me asking. This system is built upon the foundation of Nate Herk's AIS-OS combined with Andrej Karpathy's LLM-wiki guidelines. For the demo I'll show it live: open a terminal, pull the job feed from Contra, trigger a skill, watch the wiki update, then walk through the self-audit loop that finds gaps in the system and ships one improvement per week. The repo stays visible throughout. No slides. We may jump into live client / prospects on Contra.

- Event context: AI Tinkerers Barcelona - September Demo Night — 2026-09-17 — Barcelona
- Public talk page: https://barcelona.aitinkerers.org/talks/rsvp_AA_yQ6WeHtc

### [SkillCheck - building linter for Agent Skills](https://copenhagen.aitinkerers.org/talks/rsvp_E9DOLVyNJX4)

MCP server checking Agent Skills for compliance with standards, semantic coherence, structure, quality patterns and more.

- Event context: September Demo Night — 2026-09-16 — Copenhagen
- Public talk page: https://copenhagen.aitinkerers.org/talks/rsvp_E9DOLVyNJX4

### [Here be Dragons -- agentic programming the hard stuff](https://durango.aitinkerers.org/talks/rsvp_MlGmL7fmWYg)

I made an operating system/kernel! We'll talk about pushing agentic programming solidly outside the mainstream, how well it deals with very demanding projects, what methods of guiding the LLM worked best for me, and how to approach projects that are neither one-shot nor vibecoding compatible. Demo: the kernel in a VM. We'll skim my Fable chat logs for studying and deciding software architecture, as concrete examples of how to form short to the point prompts that get results.

- Event context: AI Tinkerers Durango — September Lunch Builder Meetup — 2026-09-15 — Durango
- Public talk page: https://durango.aitinkerers.org/talks/rsvp_MlGmL7fmWYg

### [Coding on dog walks over the years](https://boston.aitinkerers.org/talks/rsvp_JsuBvLBOFkM)

I've been tinkering with coding by voice since ChatGPT came out. I'll demo my latest iteration Openbase, which to my knowledge is the most capable voice coding solution currently available (even though it is currently not the fastest). Openbase is designed for work on real production apps, and optimized for splitting work between a team of agents, each with their own names, voices, and tasks. Start Codex and Claude Code threads on your machine like normal, then pick them up from mobile with voice-to-voice. Steer, queue, abort, confirm dangerous actions, and plan mode all supported over voice. Other features of Openbase are under active development (please reach out if you'd like to team up!) - Syncs your filesystem and AI coding threads across devices (solves the problem of: "should I start this thread on my laptop or mac mini/remote devbox") - Optionally bundles Tailscale for easy single-account installation - (Codex only ATM): Start a long-running turn, and steer it from voice, even if it hasn't finished running yet. Claude Code you can resume but only after a turn has completed. Full docs at https://docs.openbase.cloud/

- Event context: Back from Summer: AI GTM Builders — 2026-09-03 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_JsuBvLBOFkM

### [How to beat any benchmark with recursive self improvement](https://amsterdam.aitinkerers.org/talks/rsvp_PpT8TxQ4mtA)

I did build a system that autonomously evaluates and improves agents. The approach is backed by this paper: https://arxiv.org/abs/2603.28052 I applied this to a known agentic benchmark called Tau-bench from Sierra.ai. As a result I'm able to beat the benchmark by 10% on multiple domains.

- Event context: AI Tinkerers Demo Night: Agents in Various Forms — 2026-09-03 — Amsterdam
- Public talk page: https://amsterdam.aitinkerers.org/talks/rsvp_PpT8TxQ4mtA

### [Salve tudo o que puder: buscador local que acha qualquer coisa da minha vida em 25ms](https://curitiba.aitinkerers.org/talks/rsvp_htrQvE_vtiI)

lux_find is a local full-text search index for everything you already have on disk: markdown notes, source code, and exported chat histories with coding agents. One SQLite file, BM25 ranking over FTS5, no server, no cloud, no runtime dependencies — about 2,000 lines of standard-library Python you can read in an afternoon. lux-find init points it at your folders, index builds or refreshes the index in seconds, find answers in milliseconds, and find --json gives a coding agent the same results as context. Demoed live at AI Tinkerers Curitiba as "Buscador Local: Salve Tudo".

- Event context: AI Tinkerers Curitiba: Encontro de Agosto (no EBANX) — 2026-08-26 — Curitiba
- Public talk page: https://curitiba.aitinkerers.org/talks/rsvp_htrQvE_vtiI

### [AI-utomated open source project](https://missoula.aitinkerers.org/talks/rsvp_8vucNXtGqcw)

I use scheduled loops with Claude Code to build, maintain, and enhance the myIO project for data visualization

- Event context: AI Tinkerers – Missoula Inaugural Meetup · 26 August 2026 — 2026-08-26 — Missoula
- Public talk page: https://missoula.aitinkerers.org/talks/rsvp_8vucNXtGqcw

### [Goals MCP for preventing agents from reporting "Fake Done"](https://missoula.aitinkerers.org/talks/rsvp_bd91Kk9nVv8)

Show case of the goals mcp ( https://github.com/brucepro/goals_mcp ) in real time on a project using claude code. The primary purpose of the MCP is to prevent an agent from providing a done message when the work has not been completed.

- Event context: AI Tinkerers – Missoula Inaugural Meetup · 26 August 2026 — 2026-08-26 — Missoula
- Public talk page: https://missoula.aitinkerers.org/talks/rsvp_bd91Kk9nVv8

### [Architecture testing for agents](https://wellington.aitinkerers.org/talks/rsvp_spGYYjCvPOs)

I built UKPT, a project template and harness for agentic development in Kotlin Multiplatform. This project uses architecture testing to create readable documentation and strict guardrails for AI agents. It is an extension on top of the Konsist architecture testing framework. I use this system to build multiple products in parallel: Reglyph, Leegaa, Groundtruth, WoolOnline, and Sensori.

- Event context: AI Tinkerers Wellington: Inaugural Meetup · 26 August 2026 — 2026-08-26 — Wellington
- Public talk page: https://wellington.aitinkerers.org/talks/rsvp_spGYYjCvPOs

### [Measuring velocity direction in AI Era](https://islamabad-rawalpindi.aitinkerers.org/talks/rsvp_a5xgW0Yy5VY)

Momentum; A velocity measuring tool that helps in driving teams in right direction with the right velocity in AI Era. ## THE DEMO A real internal system that we're using and still building to measure velocity, direction and overall organization's momentum. We'll talk about how each matric is being captured, how multiple matrices are complimenting each other and how various team roles i.e. admin, team lead or individual member can read them.

- Event context: AI Tinkerers Islamabad - August 15, 2026 — 2026-08-15 — Islamabad Rawalpindi
- Public talk page: https://islamabad-rawalpindi.aitinkerers.org/talks/rsvp_a5xgW0Yy5VY

### [Directed by Claude — Let AI use your App](https://bremen.aitinkerers.org/talks/rsvp_rk1k-89-Avk)

An agent that operates our product through its own UI — logs in, opens menus, types, reads the screen. Three uses came out of that: it finds its own bugs while building, the runs became an end-to-end suite, and the same rig shoots our demo videos. The video I'll play is one of its outputs.

- Event context: AI Tinkerers Bremen — 2026-08-14 — Bremen
- Public talk page: https://bremen.aitinkerers.org/talks/rsvp_rk1k-89-Avk

### [My Robot Arm Learned to Cheat Its Own Scoreboard](https://bremen.aitinkerers.org/talks/rsvp_8U64PBJUX-Q)

A headless Claude Code agent controls a SO-ARM101 arm in MuJoCo through a single CLI, camera-only, while a second LLM rewrites its skill scripts between batches — every change A/B'd on held-out seeds.

- Event context: AI Tinkerers Bremen — 2026-08-14 — Bremen
- Public talk page: https://bremen.aitinkerers.org/talks/rsvp_8U64PBJUX-Q

### [Claude Code Forgets Between Sessions. I Built a Fix.](https://atlanta.aitinkerers.org/talks/rsvp_F2czpdWF3xs)

I built MLA, a context coordination layer that keeps Claude Code's working context consistent and up to date across sessions. The problem is simple: during one coding session, Claude discovers an important constraint, changes an architectural decision, or learns that an old assumption is wrong. Then you start a new session and that working context is gone. Teams try to preserve it in CLAUDE.md, documentation, memory files, rules, or other knowledge systems, but those systems eventually drift because staying current still depends on a human or agent remembering to make the update. I initially thought this was just my workflow. After talking with 30+ developers using coding agents, the same failure mode kept showing up. MLA maintains an active source of truth as coding work happens. It captures important decisions and discoveries, preserves where they came from, detects conflicting or outdated information, and keeps track of what is currently valid. When a new Claude Code or Codex session starts working, MLA gives it the relevant current context before it acts. I'll demo the full loop live: something changes during one coding session, the source of truth is updated, then a fresh session starts with an outdated assumption and MLA supplies the current information automatically. I'll also show the hooks, retrieval path, traces, and governance behind the handoff.

- Event context: AI Tinkerers Atlanta x AI Collective: Community Demos at ATL Tech Week — 2026-08-13 — Atlanta
- Public talk page: https://atlanta.aitinkerers.org/talks/rsvp_F2czpdWF3xs

### [Making local elections more transparent with AI](https://la.aitinkerers.org/talks/rsvp__2-l-YlpnxM)

Local elections decide a lot and almost nobody covers them. California city races are nonpartisan by law, so the ballot doesn't share a candidate's party, and local coverage of city hall has thinned to almost nothing. The records are public but unusable: filings as PDFs, a county voter file behind a paywall, endorsements scattered across a dozen sites. Torrance Watch is the public reference that could not exist before LLMs. Every contested race, every candidate covered the same way: background, where they stand, who endorsed them, and who is funding them, split into direct contributions, independent PAC spending, and how many donors actually live in Torrance. Every claim is footnoted to a filing you can open, and equal treatment is a compile gate, so a race covered unevenly fails to build. About 26,000 people used it, and roughly a quarter million saw the findings across Facebook groups, Reddit and Nextdoor. The busiest day was June 8, mid-count, not election night. It forecast the count and called four races itself, for a city of 145,000, because no wire service covers a city election. And it put a number on the money: $148,000 from Orange County real estate PACs across the five races, seven times what Torrance public-safety unions spent. Claude Code built it: 423 merged pull requests, one person, April to August. Six pipelines work the review queues, matching 2,543 donors against 6.4 million voter registrations, checking endorsements against their sources, and drafting candidate profiles. A deterministic scorer runs first and settles what it can. What it cannot resolve goes to LLM judges working under rules written before the run, and every decision records who made it. For the hardest cases three models judge separately, blind to the matcher's own pick, and the label only counts if all three agree. Nothing about it is specific to Torrance. The same pipeline would work for any city.

- Event context: AI Tinkerers LA — August 6: Builder Meetup & Live Demos — 2026-08-07 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp__2-l-YlpnxM

### [Agents write the code, phones approve the merge: device-in-the-loop CI for AI-built mobile apps](https://seattle.aitinkerers.org/talks/rsvp_RZQnTBW084M)

An AI-assisted delivery workflow where coding agents ship mobile apps and physical phones give the final approval. A GitHub issue gets claimed by a Claude Code agent running in a long-lived tmux loop. The agent opens a PR with tests. CI on a self-hosted runner then installs the build on a real Pixel and a Wear OS watch through custom MCP device-control servers, runs the acceptance check, and posts device screenshots back to the PR. Live: the loop end to end on real hardware, MCP tool-call traces, the CI wiring, and the watchdog code that keeps a multi-day agent loop alive. Prerecorded backup for the device segment in case venue wifi dies.

- Event context: AI Dev Tools Track - Seattle - August 4 — 2026-08-05 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_RZQnTBW084M

### [Stop scripting agents. Declare them](https://columbus.aitinkerers.org/talks/rsvp_nxcdBN7W9d0)

Fresh off YC P26, @Dan Barrett (Founder & CEO, OpenProse) is joining us. OpenProse is an open-source operating system for reliable long-running agents: a declarative language plus a reactive runtime for agent workflows, letting you write programs in structured English and execute them with an agent like Claude Code.

- Event context: AI Tinkerers - Columbus August Meetup — 2026-08-03 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_nxcdBN7W9d0

### [Stop Re-Reading Your Conference Notes: Build a Spaced-Repetition Course Instead.](https://columbus.aitinkerers.org/talks/rsvp_-a2BC9vkaEk)

A personal learning platform that turns everything I captured at AI Engineer World's Fair 2026 (53 talk transcripts, wearable-recorder audio, 167 photos and videos) into a keyboard-first spaced-repetition course, built almost entirely by an orchestrated fleet of Claude agents. I started by researching the learning-science literature (retrieval practice, FSRS spaced repetition, the Feynman technique) and encoded those techniques as the product spec. Then agents matched my camera roll to the conference schedule, wrote 66 lessons across two courses (the conference itself, plus a formal-methods course from a folder of university PDFs), generated 274 retrieval cards, and typeset real MathML formulas. Everything compiles to one dependency-free HTML file with an FSRS-5 scheduler I implemented from the published weights. I'll demo the working system live: the review queue, my own conference photos matched to the right talks, clickable scholar bios, and the generator pipeline that lets agents write validated JSON instead of HTML.

- Event context: AI Tinkerers - Columbus August Meetup — 2026-08-03 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_-a2BC9vkaEk

### [Robot Picks Grapes Based on Spatial World Model](https://seattle.aitinkerers.org/talks/rsvp_hwjgpFnwm2M)

We built a new model that is based on the human brain. Right now it can navigate and reason to play Pac Man but we are working on connecting it to a robot and having it pick grapes.

- Event context: AI Tinkerers Seattle Summer Bash — 2026-07-29 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_hwjgpFnwm2M

### [Programmatic SEO in the agentic era](https://valencia.aitinkerers.org/talks/rsvp__Qlw98YbdyU)

https://www.wegravel.com/ is a bulk construction materials marketplace in the US. We built a programmatic SEO engine: 1300 pages generated — every material × city combination in Florida — no dev team, no ad spend. I'll show the live pages ranking, the real Search Console curves (impressions and clicks climbing), the generation workflow, and the surprise: our pages showing up in ChatGPT search. All production. Real traffic, real leads, real customers.

- Event context: AI Tinkerers Valencia July Demo Night — 2026-07-28 — Valencia
- Public talk page: https://valencia.aitinkerers.org/talks/rsvp__Qlw98YbdyU

### [pi-hydra: Mob Programming for Coding Agents](https://cologne.aitinkerers.org/talks/rsvp_WhIovGtreZ0)

pi-hydra is an open-source extension for pi.dev, a coding agent harness, that adds observer "heads". A head reviews the agent's work while the agent is still working. Each head is one markdown file with its own lens. The repo ships six as examples, but you write your own or tell the agent to write one. After every step a head makes an observation and decides: stay quiet, print a note for me, queue feedback for the next turn, steer the agent mid-run, or interrupt the run entirely. The author came to this from mob programming, one driver at the keyboard and several navigators watching the same screen. Most agent tooling points the other way and delegates work down to a worker that builds its own context and hands back a result. A head goes up instead. It sits above the driver, watches the same run, and can act on what it sees. It also does not have to rebuild context: each observation is a fork of the driver's own provider request, replayed byte-for-byte so it rides the prompt cache the driver already paid for. In the Anthropic sessions the author measured, one always-on head adds roughly 30% to total session cost, and a second head about the same again. A head sees everything the driver sees, so it inherits the driver's framing and blind spots too. It catches many problems while they are cheap, but it does not replace the independent review at the end. In the demo, an agent added a feature to an existing service while two heads watched. One caught a security hole the agent had inherited and never thought to check. The other caught the agent quietly swallowing errors in code it was writing at that moment. Both steered the fix in mid-run without derailing the original task. Three prompts, about two minutes.

- Event context: AI Tinkerers Cologne: World Cup Edition — 2026-07-15 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_WhIovGtreZ0

### [Turn your Homelab into a Dark Factory](https://cologne.aitinkerers.org/talks/rsvp_iWZxTrC9hQ8)

I turned my Homelab into a dark factory where I run an orchestrating agent that schedules and delegates work to other agents. There are two parts to this system: the control plane, which handles where agents run and how they run, and the data plane, which handles the actual work you commit (or not). We're going to see how I interact with a personal agent (Hermes, if I have time, I'll show my own agent) and how Hermes decides what to do next depending on our conversation. Instead of making Hermes write the code, it will delegate the tasks to different coding agents running in our own sandbox (built with Firecracker on top of a Proxmox VM). I'll walk you through the different components, how it works and why it matters (in particular the sandbox part).

- Event context: AI Tinkerers Cologne: World Cup Edition — 2026-07-15 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_iWZxTrC9hQ8

### [Verification with LLM powered Behavior Driven Development (BDD)](https://seattle.aitinkerers.org/talks/rsvp_abgJncjsLmk)

At SageOx, we've built test tooling that has raised the conceptual level of E2E tests from traditional code to human natural language. We've married the old idea of BDD (Behavior Driven Development) with LLMs to reduce the cognitive debt of designing and reviewing acceptance criteria for agent generated code. In my demo, I will show you a test scenario can be defined using natural language in the Gherkin format, have a coding agent turn that into a test run plan that exercises our Web UI, CLI and integration in Claude Code. And, then show a trace of the test running against these multiple interfaces in a single pleasing test report.

- Event context: AI Dev Tools Track - Seattle - July 13 — 2026-07-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_abgJncjsLmk

### [Operating an Agentic Homelab with Agent Guides](https://seattle.aitinkerers.org/talks/rsvp_wvjI8VfiuMM)

I built a multi-node homelab with layered, enterprise-grade security (passwordless auth, secrets management, host hardening) and an OpenTofu plus Ansible control plane for infrastructure and deployment. AI agents operate it instead of me clicking through consoles. In order to facilitate rapid iteration and configuration I created a new open-standard data format called Agent Guides, which are open, Skill-compatible markdown runbooks. Provisioning a new LXC, rotating credentials, or updating firewall settings are repetitive over time, but the details drift and some of the APIs have undocumented behavior, so a single prompt is unreliable and a fixed script breaks. Plain wiki runbooks aren't ideal because they go stale as soon as the environment changes. What I wanted was documented procedures an agent can follow but still improvise when it hits something unexpected. The guides for my homelab are executed primarily by agents, whose harness leaves an audit log to review afterwards, so another agent may update the guide automatically instead of rediscovering the same problem the next time.

- Event context: AI Dev Tools Track - Seattle - July 13 — 2026-07-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_wvjI8VfiuMM

## Related Technologies

- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 129 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [Codex](https://aitinkerers.org/technologies/codex) ([Markdown](https://aitinkerers.org/technologies/codex.md)) — 44 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 186 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 188 public demos
- [Supabase](https://aitinkerers.org/technologies/supabase) ([Markdown](https://aitinkerers.org/technologies/supabase.md)) — 90 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 173 public demos
- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 219 public demos
- [Cursor](https://aitinkerers.org/technologies/cursor) ([Markdown](https://aitinkerers.org/technologies/cursor.md)) — 65 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 520 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 74 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [Anthropic API](https://aitinkerers.org/technologies/anthropic-api) ([Markdown](https://aitinkerers.org/technologies/anthropic-api.md)) — 66 public demos
- [Markdown](https://aitinkerers.org/technologies/markdown) ([Markdown](https://aitinkerers.org/technologies/markdown.md)) — 24 public demos
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 99 public demos
- [Vercel](https://aitinkerers.org/technologies/vercel) ([Markdown](https://aitinkerers.org/technologies/vercel.md)) — 48 public demos
- [Gemini CLI](https://aitinkerers.org/technologies/gemini-cli) ([Markdown](https://aitinkerers.org/technologies/gemini-cli.md)) — 16 public demos

## More Results

- Next: https://aitinkerers.org/technologies/claude-code.md?page=2