# 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-02-22T15:27:06Z
> Generated: 2026-08-25T15:16:10Z

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: 204
- Result page: 1 of 9

## Recent Public Talks and Demos

### [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)

WeGravel 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

### [Researching agent memory](https://columbus.aitinkerers.org/talks/rsvp_9_U1zLJVobc)

What started as a conversation to understand agent memory frameworks turned into a directory website and a fully autonomous self learning researcher and reporter.

- Event context: AI Tinkerers - Columbus July Meetup — 2026-07-06 — Columbus
- Public talk page: https://columbus.aitinkerers.org/talks/rsvp_9_U1zLJVobc

### [Building Agentic OS for Marketing](https://denver-boulder.aitinkerers.org/talks/rsvp_BZZDcloDPXM)

I have been solo for 3 years after selling my Denver marketing agency. I was doing everything low code until early March when I discovered Claude Code and working at the terminal. I know have moved my system to a full dev stack using Neon, Claude Managed Agents, 5 repos (website, clients, agent os, reporting admin app) to run my entire AI native consultancy with 12+ clients.

- Event context: AI Tinkerers Denver - June Meetup — 2026-06-30 — Denver
- Public talk page: https://denver-boulder.aitinkerers.org/talks/rsvp_BZZDcloDPXM

### [The Blueprint of a North Korean Attack on Open-Source](https://sf.aitinkerers.org/talks/rsvp_OPre5EDPY9A)

I reverse engineered an attempted attack on better-auth, one of the most popular auth libraries on npm. My demo shows you a step-by-step what happens when your repo is under attack and damage it can cause.

- Event context: AI Tinkerers San Francisco: Offensive Security Demo Night — 2026-06-26 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_OPre5EDPY9A

### [Hacking The Browser For Fun ~And Profit~](https://sf.aitinkerers.org/talks/rsvp_dZETAb_xF00)

We'll talk about XBOW's research into native application hacking: the agents' structure, objectives, and inner "iteration" patterns which worked to discover a few dozen high severity bugs in Chromium, including demoing an exploit of one vulnerability which has already been patched.

- Event context: AI Tinkerers San Francisco: Offensive Security Demo Night — 2026-06-26 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_dZETAb_xF00

### [Build a dark factory that’s right for you](https://tokyo.aitinkerers.org/talks/rsvp_F9L8oeUgPp4)

A dark factory for code: an autonomous, multi-agent build crew in Claude Code. I describe what I want in plain language, and a crew of Claude agents does the labour — designing, building, testing, and double-checking — with a single human yes/no before anything lands on main. Work is batched into waves: each wave splits into tasks, and every task runs a fixed five-stage cycle — brainstorm → implement → test → review → wrap-up — as its own Claude Code subagent in its own git worktree, so many build in parallel without colliding. The factory runs each agent as a full interactive Claude session in a tmux pane (rather than headless claude -p), signalled complete by a Stop-hook; I drive and watch the windows through cmux. The whole run is journaled to an on-disk ledger, so it survives reboots and resumes where it left off. The quality net is a Claude Code skill I lean on constantly — a talmudic study, where N orthogonal expert agents each write an independent position on a design, then argue it out (filing challenges, conceding points, revising) until a redactor synthesizes one settled design with the dissent preserved. The factory runs two of these panels over every finished wave and auto-spawns corrective tasks for anything they catch. Then it parks the wave at a "front desk" and asks the only question I ever have to answer: merge, or hold? I'll show how it's wired and share the two pieces that do the most work — the talmudic-study skill, and the plain-language map of the factory itself. Two things are shared here. Both are deliberately product-agnostic — the patterns work on any codebase.

- Event context: AI Tinkerers Tokyo - Shinagawa: June 18th Meetup — 2026-06-18 — Tokyo
- Public talk page: https://tokyo.aitinkerers.org/talks/rsvp_F9L8oeUgPp4

### [Graph-Oriented Generation: Deterministic Context Retrieval for Code](https://manchester-nh.aitinkerers.org/talks/rsvp_SMbTB_Lslqs)

GOG (Graph-Oriented Generation) is a deterministic context-retrieval system for code generation: instead of embedding chunks and pulling them by similarity, it parses the codebase into an AST-derived graph and traverses it to assemble precise context for a prompt. Live, I'll run the same prompt through Claude Code two ways — vanilla, and with GOG injecting context — and walk the full path from the initial prompt, through decomposing the project structure into stratum relationships, to the actual AST graph traversal that selects what the model sees. You'll see the retrieval working, not a slide about it.

- Event context: AI Tinkerers Manchester (Bedford), NH - June 2026 Meetup — 2026-06-17 — Manchester NH
- Public talk page: https://manchester-nh.aitinkerers.org/talks/rsvp_SMbTB_Lslqs

### [Claude Code e Google Vertex para Experimentos de Machine Learning](https://curitiba.aitinkerers.org/talks/rsvp_OoWoCfnBRoo)

É uma apresentação sobre como é possível utilizar claude code em seu computador para realizar experimentos de machine learning. A apresentação mostra o fluxo de trabalho para realizar experimentos a partir de uma idéia. Também se demonstra a possibilidade de utilizar Google Vertex AI para trabalhar com a Cloud caso seu computador principal não seja suficiente para experimentos que necessitam de mais recursos.

- Event context: AI Tinkerers Curitiba: Evento Inaugural — 2026-06-10 — Curitiba
- Public talk page: https://curitiba.aitinkerers.org/talks/rsvp_OoWoCfnBRoo

### [Engenheiro civil + Claude Code: app de terraplenagem 100% determinístico construído por conversa](https://curitiba.aitinkerers.org/talks/rsvp_iwCDvtHEc-s)

KML Earthworks é um app Streamlit que transforma um traçado de estrada de acesso desenhado no Google Earth em estimativa de terraplenagem (perfil longitudinal, volumes de corte/aterro pela fórmula do prismatoide, balanço de massa, diagrama de Bruckner) em segundos — upload de .kml, download de Excel, zero GIS de desktop. Na demo eu vou: (1) desenhar um acesso ao vivo no Google Earth e rodar o app em produção (kml-earthworks.streamlit.app) mostrando o pipeline completo (parse → stationing a cada 20m → enriquecimento de elevação com fallback de API → otimização de grade → volumes → export); (2) abrir o repo no editor e mostrar a estrutura src/ modular, o CLAUDE.md que funciona como guideline persistente para o agente, e rodar os 58 testes ao vivo no terminal; (3) navegar pelos commits para mostrar a evolução notebook → pacote → app por desenvolvimento conversacional com Claude Code, incluindo os pontos onde eu tive que intervir manualmente.

- Event context: AI Tinkerers Curitiba: Evento Inaugural — 2026-06-10 — Curitiba
- Public talk page: https://curitiba.aitinkerers.org/talks/rsvp_iwCDvtHEc-s

### [Cloud Zombie Hunter: An AI Agent vs. the Dead Weight on My Bill](https://medellin.aitinkerers.org/talks/rsvp_OESkSSQF6_o)

I built a terminal-based agent — Claude Code running locally — that hunts two kinds of cloud waste across AWS and Databricks in one session, with evidence and grounded dollar estimates, and never touches anything without my say-so. It looks for two things: Zombies — abandoned resources still billing. On AWS: unattached EBS volumes, unassociated Elastic IPs, NAT gateways with near-zero traffic, stale snapshots, and the one everyone forgets — orphaned CloudWatch alarms left behind when a resource is decommissioned. On Databricks: all-purpose clusters left running with no auto-termination, SQL warehouses with no auto-stop, and scheduled jobs that fail silently but keep getting provisioned. Over-provisioned / mis-configured resources. ECS services whose CPU/memory reservation dwarfs actual utilization, or with autoscaling that never triggers (min capacity too high, scale-in disabled, or tracking a metric that never moves). Oversized EC2/RDS vs Compute Optimizer. Databricks clusters with oversized worker types, autoscaling minimums set too high, all-purpose clusters doing jobs that belong on job clusters, or warehouses sized XXL where LARGE would do.

- Event context: AI Tinkerers Medellín #21 - Source Meridian - 09 de Junio — 2026-06-09 — Medellín
- Public talk page: https://medellin.aitinkerers.org/talks/rsvp_OESkSSQF6_o

## Related Technologies

- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 654 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 198 public demos
- [MCP](https://aitinkerers.org/technologies/mcp) ([Markdown](https://aitinkerers.org/technologies/mcp.md)) — 122 public demos
- [Codex](https://aitinkerers.org/technologies/codex) ([Markdown](https://aitinkerers.org/technologies/codex.md)) — 43 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 185 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 187 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 170 public demos
- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 216 public demos
- [Supabase](https://aitinkerers.org/technologies/supabase) ([Markdown](https://aitinkerers.org/technologies/supabase.md)) — 87 public demos
- [Cursor](https://aitinkerers.org/technologies/cursor) ([Markdown](https://aitinkerers.org/technologies/cursor.md)) — 62 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 518 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 73 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 144 public demos
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 96 public demos
- [Anthropic API](https://aitinkerers.org/technologies/anthropic-api) ([Markdown](https://aitinkerers.org/technologies/anthropic-api.md)) — 63 public demos
- [Gemini CLI](https://aitinkerers.org/technologies/gemini-cli) ([Markdown](https://aitinkerers.org/technologies/gemini-cli.md)) — 16 public demos
- [Markdown](https://aitinkerers.org/technologies/markdown) ([Markdown](https://aitinkerers.org/technologies/markdown.md)) — 24 public demos
- [OpenClaw](https://aitinkerers.org/technologies/openclaw) ([Markdown](https://aitinkerers.org/technologies/openclaw.md)) — 48 public demos

## More Results

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