# git Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/git
> Markdown URL: https://aitinkerers.org/technologies/git.md
> Technology record last updated: 2026-02-23T15:20:36Z
> Generated: 2026-08-26T22:17:16Z

Git is the distributed version control system (DVCS) that tracks source code changes, ensuring data integrity and enabling non-linear development workflows.

Git is the free, open-source distributed version control system (DVCS) created by Linus Torvalds in 2005 to manage the Linux kernel. Engineered for speed and efficiency, it handles projects from small to extremely large, storing the entire 1.4 million commit history of the Linux project in only 5.5 GB . Its core design supports non-linear development (branching/merging) and guarantees data integrity via cryptographic hashing. According to a 2022 Stack Overflow survey, 96% of professional developers use Git, making it the industry standard for collaborative software development .

- Official technology site: https://git-scm.com
- Public AI Tinkerers demos and talks: 23
- Result page: 1 of 1

## Recent Public Talks and Demos

### [Stateful agents with open-strix](https://raleigh.aitinkerers.org/talks/rsvp_obcR2zOygIM)

open-strix is a minimalistic open source stateful agent harness that leans on the Unix principle and uses cybernetics principles to build a tiny, solid, extensible core.

- Event context: AI Tinkerers Raleigh Meetup — May 6, 2026 — 2026-05-06 — Raleigh
- Public talk page: https://raleigh.aitinkerers.org/talks/rsvp_obcR2zOygIM

### [Building a Real-Time Terminal Messenger on LinkedIn's Private APIs with Bun, Ink, and a Git-Backed Message Store](https://seattle.aitinkerers.org/talks/rsvp_0AqXN-gxTTM)

Allman is a two-layer system for LinkedIn messaging from the terminal: a CLI that syncs, sends, and streams LinkedIn messages into a git-versioned file store, and a TUI that renders it as a full two-pane Ink/React terminal messenger with live updates, auto-backfill, and real-time presence. The demo shows the TUI in action — navigating conversations, composing replies, watching the status bar update as messages stream in over LinkedIn's SSE channel, and kicking off a sync that backfills an entire conversation history while showing live progress counts. Under the hood, the TUI never touches the network directly. Every write — sends, syncs, searches — shells out to the lilac binary, which is embedded inside the compiled TUI executable as a bundled asset. Every read — conversation list, message thread, slug lookup — goes straight to JSONL files on disk, so navigation is instant with zero subprocess overhead per keystroke. The key learning or takeaway is that private APIs, even when obfuscated, are easily reverse-engineered by coding harnesses. Claude Opus 4.6 processed the compiled LinkedIn binary overnight, completely autonomously.

- Event context: AI Tinkerers Seattle: GTM Engineering — April Meetup — 2026-04-23 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_0AqXN-gxTTM

### [Orchestra — coordinating 10+ coding agents without becoming the bottleneck](https://seattle.aitinkerers.org/talks/rsvp_RmodSq4wq2Y)

I built Orchestra, a file-based coordination layer for managing multiple coding agents across repos without manually passing context between them. It turns your codebase into a shared memory + execution system using a structured .orchestra/ directory (threads, plans, decisions, handoffs, sessions), so agents can work in parallel across worktrees while staying aligned. In the demo, I’ll show how I go from problem → research → plan → parallel execution across API/frontend/infra agents, without constantly re-explaining context or micromanaging each agent.

- Event context: AI Dev Tool Track — Seattle Meetup - April 13th, 2026 — 2026-04-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_RmodSq4wq2Y

### [OpenCTO](https://paris.aitinkerers.org/talks/rsvp_TMf43kXAfHk)

OpenCTO is an AI engineering agent that can understand a codebase, make targeted changes, and prepare a production-ready pull request on behalf of a developer. It is designed to speed up routine implementation work by turning a natural language task into code edits, documentation updates, test execution, and a structured PR summary. The goal is to help teams ship faster while keeping engineering workflows transparent and reviewable.

- Event context: AI Builders Meetup Paris - OpenClaw (featuring 42 AI & HEC Vibe) — 2026-03-26 — Paris
- Public talk page: https://paris.aitinkerers.org/talks/rsvp_TMf43kXAfHk

### [Determinisim In The Agentic World](https://berlin.aitinkerers.org/talks/rsvp_OxDgz_bC0rA)

When agents can write code faster than you can review it, quality becomes the bottleneck. This talk covers how to maintain high confidence in agent generated code by applying Zed's three engineering pillars alongside a fourth rule: always give the agent a deterministic feedback loop. Using Zed's git graph as a case study, I'll walk through how property based testing lets an agent verify its own changes against invariants instead of relying on human review to catch regressions. I'll also preview a debugger tool call that gives agents direct access to runtime state. The core idea is practical. If an agent can't prove its output is correct, the velocity it gives you is a liability.

- Event context: AI Tinkerers Berlin Meetup - March 11, 2026 — 2026-03-11 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_OxDgz_bC0rA

### [Orchestrating Claude Inside Vercel Sandboxes for an Isolated Commerce Environment](https://poland.aitinkerers.org/talks/rsvp_-g6_pJg01zE)

This talk walks through how we run Claude inside per-session Vercel Sandboxes to operate on a live Next.js commerce system. Each session provisions an isolated sandbox where Claude connects via the Claude Agent SDK over WebSockets. The initial prompt fetches a Git repository of the storefront, which becomes the working workspace. From there, Claude proposes structured mutations that are applied incrementally as diffs and commits, with optional deployment to Vercel. Commerce state (products, pricing, checkout) is never modified via arbitrary code edits. Instead, mutations flow through typed calls exposed by our Commerce SDK. UI changes can be generative; transactional operations must pass validated primitives. We’re evolving the system toward an in-memory project file representation to reduce cold starts and avoid long sandbox wakeups. Mutations are first applied to this in-memory graph, then executed via Just Bash inside the sandbox, enabling background transitions while keeping the live instance responsive. The demo focuses on the WebSocket orchestration loop, sandbox isolation boundaries, tool schema design, and the failure cases we encountered while ensuring the commerce system remains consistent and deployable at all times.

- Event context: AI Tinkerers Poland x Codex - Meetup in Warsaw #7 (4th March, Wednesday) — 2026-03-04 — Poland
- Public talk page: https://poland.aitinkerers.org/talks/rsvp_-g6_pJg01zE

### [rm -rf salesforce — Claude Runs Deal Flow Now](https://seattle.aitinkerers.org/talks/rsvp_qa7m-04lrlg)

I built a git-backed knowledge base that replaces both my CRM and Google Docs for running an early-stage fund. Every entity — founders, companies, deals — lives as a folder of markdown and YAML. Claude agents are first-class participants: they process inbound emails, run entity resolution, create records, log notes, and commit directly to the repo. A GitHub Actions cron runs nightly, calling Claude Sonnet to synthesize each entity's raw files into a structured materialized summary. I'll demo the full live workflow: forward a pitch email → agent resolves the entity → creates the records → generates a materialized view → commits to git. No database. No SaaS. Just files, Claude, and git.

- Event context: AI Tinkerers Seattle: GTM Engineering Kickoff — Building AI for Growth — 2026-02-26 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_qa7m-04lrlg

### [From Ticket to PR: An Autonomous Coding Workflow with Claude Code](https://durango.aitinkerers.org/talks/rsvp_Krkk1jzEvWI)

A live demo of an end-to-end agentic coding framework that takes a Linear ticket ID and autonomously executes a structured 10-stage workflow; from ticket discovery all the way through branch setup, planning, implementation, self-directed code review, PR creation, and cleanup. The workflow is triggered by a single slash command (/work-ticket TK-123) and Claude Code handles the rest: reading the ticket, detecting scope, writing and reviewing code, updating ticket status, opening the PR, and producing a final summary. No manual handoffs, no context switching, just a ticket in and a pull request out.

- Event context: AI Tinkerers Durango: Code and Show'n'tell — 2026-02-24 — Durango
- Public talk page: https://durango.aitinkerers.org/talks/rsvp_Krkk1jzEvWI

### [Should You Obey Your AI Reviewer?](https://brussels.aitinkerers.org/talks/rsvp_3tv20yxQ8mQ)

"Code Quality" is a system that posts feedback comments on your pull requests. We'll take a deep dive into how we hide non-determinism caused by LLMs and how we optimize the LLM's accuracy.

- Event context: AI Tinkerers Ghent Meetup - February 11 — 2026-02-11 — Brussels
- Public talk page: https://brussels.aitinkerers.org/talks/rsvp_3tv20yxQ8mQ

### [Poor Man’s Long Running Multi Hour Coding Agent](https://seattle.aitinkerers.org/talks/rsvp_2_7aWPHU1uc)

In December 2025, I was running out of time. In an act of desperation and after reading Anthropix's blog post or paper about long-running agentic harnesses, I attempted to replicate what they described in their paper and was able to achieve over a long weekend the completion of a feature done enough and well enough that I could ship and meet my deadline. The outcome of this was over that weekend I completely maxed out my Claude Max subscription and then on top of that I incurred an overage of $700.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — February 9th, 2026 — 2026-02-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_2_7aWPHU1uc

### [Development automation with Claude Code](https://seattle.aitinkerers.org/talks/rsvp_hcHs0cIwhQE)

This will probably continue evolving - this is my current Claude Code setup & it allows me to function as a supervisor as my AI Agent crunches through and verifies large parts of the codebase itself - also includes a bunch of helpful functionality baked in Some things it does well: * Spec-driven development - automated checks to ensure document to doc consistency * Enforces TDD and automated verification * Automated git-based workflow * Stuck detection for agents in loops * Support features and greenfield

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — February 9th, 2026 — 2026-02-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_hcHs0cIwhQE

### [Parallelizing Agents with Git Worktrees](https://asuncion.aitinkerers.org/talks/rsvp_F0jjunc-SJE)

In this demo, I’ll start with a brief introduction to Git worktrees, explaining what they are, how they work, and why they’re useful when working with a single repository across multiple tasks. This quick overview will provide the foundation needed to understand the rest of the demo. From there, I’ll show how Git worktrees can be used to run multiple agents in parallel, each operating in its own isolated working tree. This allows you to work on multiple features, experiments, or fixes at the same time without worrying about conflicting file changes, frequent branch switching, or stepping on each other’s work. I’ll demonstrate how this setup enables true parallel development: each agent can independently make changes, run tests, and iterate, while still sharing the same underlying Git history. This approach is particularly effective for coordinating autonomous or semi-autonomous agents, as it minimizes merge friction, reduces context switching, and scales naturally as the number of concurrent tasks grows. By the end of the demo, you’ll have a clear, practical understanding of both Git worktrees and how to use them to parallelize agent workflows, helping you move faster while keeping your development process clean and conflict-free.

- Event context: Último Encuentro del Año: AI Tinkerers Asunción — 2025-12-18 — Asunción
- Public talk page: https://asuncion.aitinkerers.org/talks/rsvp_F0jjunc-SJE

### [Encoding Regulation: A Minimal Policy-as-Code Engine for Transaction Screening](https://bremen.aitinkerers.org/talks/rsvp_QUe96TzohsM)

I will demo a small policy-as-code engine I built to explore how regulatory rules can be expressed as executable logic. The system takes human-readable YAML rules (e.g., thresholds, jurisdictions, prohibited transaction types), parses them into an internal structure, and evaluates each incoming transaction through a deterministic constraint pipeline. The core of the demo is the implementation: the rule parser, the abstract syntax tree used to normalise heterogeneous conditions, and the evaluator that resolves multiple matching rules into a single “allow/block/flag” decision. Instead of slides, I will walk through the code that loads rules, interprets conditional operators, handles conflicts, and surfaces intermediate evaluation steps. I’ll also show a tiny sandbox where modifying a rule immediately changes system behaviour, illustrating how policy logic propagates through the engine. The goal is not to pitch a product but to share the technical challenges of translating messy institutional rules into a minimal, functioning execution model.

- Event context: AI Tinkerers Bremen — 2025-12-10 — Bremen
- Public talk page: https://bremen.aitinkerers.org/talks/rsvp_QUe96TzohsM

### [Beads: My coding agent memory bank & planning system](https://seattle.aitinkerers.org/talks/rsvp_6lBG3aBqrV4)

I'll give a live demo of my workflow with multiple coding agents on multiple projects using Beads. Beads is a lightweight issue tracker that replaces markdown files for agent planning. It turns your implementation plan into a big queryable graph, so you can sit down in every new session and just say, "what's next?"

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — November 3, 2025 — 2025-11-04 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_6lBG3aBqrV4

### [Automate - SEO, one line web optimised pages](https://sydney.aitinkerers.org/talks/rsvp_OepS7AbUY3g)

A coding agent workflow I built (with cursor background) to enable non technicals to build in our single repo

- Event context: AI Tinkerers – Sydney Inaugural Meetup · 20 August 2025 — 2025-08-20 — Sydney
- Public talk page: https://sydney.aitinkerers.org/talks/rsvp_OepS7AbUY3g

### [TSK: Open Source Coding Agent Task Manager and Sandbox](https://seattle.aitinkerers.org/talks/rsvp_VDq4Kxmpqq0)

If you've used AI coding tools like Cursor, Claude Code, or Aider, you know the drill: constant babysitting to prevent hallucinations, accidental file deletions, or worse - credential leaks. You want the productivity boost, but not the anxiety. TSK (pronounced "task") solves this by letting you delegate work to AI agents safely. Queue up tasks, walk away for that 5th coffee or meeting, and come back to completed git branches ready for review. Each task runs in an isolated Docker container on your local machine - agents can code, test, and iterate without touching your main environment or accessing sensitive files. Think of it as having a team of developers who submit pull requests instead of pushing directly to main. You maintain control while getting the productivity benefits of autonomous AI work. I'll demo TSK implementing a new feature live - you'll see how easy it is to delegate work and review results on your timeline, not the AI's.

- Event context: AI Tinkerers Seattle – June Meetup — 2025-06-28 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_VDq4Kxmpqq0

### [Building KOTA: A Practical Approach to Distributed Cognition](https://seattle.aitinkerers.org/talks/rsvp_DOfJoRSu2UY)

This talk dives into the journey of building KOTA (Knowledge-Oriented Thinking Assistant), a personal cognitive partner developed iteratively using simple, accessible tools: markdown files, Python scripts, and the Aider command-line AI coding tool. We'll explore how KOTA evolved from a basic knowledge base into a practical implementation of distributed cognition, where the system gains agency to manage its own structure and even initiate tasks (like sending Telegram notifications or running overnight builds). Discover the techniques used to integrate personal data securely (prioritizing local LLMs), the surprising effectiveness of this minimalist approach, and its real-world impact on productivity – enabling rapid development cycles like building multiple micro-SaaS products in weeks ("Project Mosaic"). Learn the core principles and get a practical starting guide to building your *own* personalized cognitive extension, fostering AI partnership beyond reliance on closed, corporate systems.

- Event context: AI Tinkerers Seattle - April Meetup — 2025-04-25 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_DOfJoRSu2UY

### [Tool Use + Mozilla Blueprints](https://toronto.aitinkerers.org/talks/rsvp_xlgsVBRz7oQ)

Mozilla Blueprints are customizable workflows that help developers build AI applications using open-source tools and models. They are teaming up with Mike and Ty from Tool Use to help more people learn about this great initiative. They put together AI commit, a basic tool to generate strong git commit messages using AI, all local. This Blueprint is a good demonstration for how anyone can build CLI tools quickly and easily.

- Event context: AI Tinkerers Toronto - March 2025 Meetup at Mozilla — 2025-03-27 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_xlgsVBRz7oQ

### [marimo: an open-source reactive notebook for Python](https://nyc.aitinkerers.org/talks/rsvp_cQ4a3xVEx7w)

marimo is a reactive notebook for Python, solving many problems associated with traditional notebooks like Jupyter. Reproducibility: marimo guarantees that your code, outputs, and program state are consistent, eliminating hidden state and making your notebook reproducible Maintainability: marimo notebooks are stored as pure Python programs (.py files). This lets you version them with git. Interactivity: marimo notebooks come with UI elements that are automatically synchronized with Python (like sliders, dropdowns); eg, scrub a slider and all cells that reference it are automatically re-run with the new value. Reusability: marimo notebooks can be executed as Python scripts from the command-line (since they’re stored as .py files). Shareability: Every marimo notebook can double as an interactive web app, complete with UI elements.

- Event context: End of Summer Technical Founder BBQ — 2024-09-17 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_cQ4a3xVEx7w

### [Transforming Code Collaboration with Aider: AI-Powered Pair Programming](https://fort-wayne.aitinkerers.org/talks/rsvp_fd5h26pQoac)

Meet Aider —an open-source tool that's redefining how developers work with large codebases. Aider seamlessly integrates with Git, leveraging AI models like GPT-4o and Claude Sonnet 3.5 to offer real-time code suggestions, multi-file edits, and automatic commits, all within your terminal. In my upcoming presentation, I'll be showcasing how Aider can be used to create real, functional code while demonstrating its powerful capabilities. We’ll explore how this tool can make the impossible possible, whether you're refactoring, fixing bugs, or adding new features. Check out Aider on GitHub and learn more at https://aider.chat 🌐

- Event context: AI Tinkerers Fort Wayne August 20th 2024 Meet up — 2024-08-20 — Fort Wayne
- Public talk page: https://fort-wayne.aitinkerers.org/talks/rsvp_fd5h26pQoac

### [CodeDD - AI based code due diligence](https://vienna.aitinkerers.org/talks/rsvp_fPek6RNCqtM)

A tool for AI (LLMs) based code review for startups and investors alike. Easy: Copy git repo Complete: +40 code quality parameters Secure: No line of code is disclosed or stored

- Event context: AI Tinkerers Vienna ICML Edition — 2024-07-24 — Vienna
- Public talk page: https://vienna.aitinkerers.org/talks/rsvp_fPek6RNCqtM

### [momentum - ensure code correctness at every git push](https://sf.aitinkerers.org/talks/rsvp_kVITxR9pLHE)

momentum is a code auditor that analyses the necessary code behavior and tests it at every git push to ensure the code is ready for production.

- Event context: AI Tinkerers - San Francisco - Summer Edition - July 2024 — 2024-07-12 — San Francisco
- Public talk page: https://sf.aitinkerers.org/talks/rsvp_kVITxR9pLHE

### [momentum - ship your backend with confidence](https://bengaluru.aitinkerers.org/talks/rsvp_ZFaNolQ0otk)

momentum is a code auditor that analyses the necessary code behavior and tests it at every git push to ensure the code is ready for production.

- Event context: AI Tinkerers - Bangalore Inaugural - RSVP REQUIRED — 2024-06-02 — Bengaluru
- Public talk page: https://bengaluru.aitinkerers.org/talks/rsvp_ZFaNolQ0otk

## Related Technologies

- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 205 public demos
- [GPT-4](https://aitinkerers.org/technologies/gpt-4) ([Markdown](https://aitinkerers.org/technologies/gpt-4.md)) — 529 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 654 public demos
- [BERT](https://aitinkerers.org/technologies/bert) ([Markdown](https://aitinkerers.org/technologies/bert.md)) — 179 public demos
- [GPT-3](https://aitinkerers.org/technologies/gpt-3) ([Markdown](https://aitinkerers.org/technologies/gpt-3.md)) — 191 public demos
- [BLOOM](https://aitinkerers.org/technologies/bloom) ([Markdown](https://aitinkerers.org/technologies/bloom.md)) — 115 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 171 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 73 public demos
- [Llama-2](https://aitinkerers.org/technologies/llama-2) ([Markdown](https://aitinkerers.org/technologies/llama-2.md)) — 227 public demos
- [Markdown](https://aitinkerers.org/technologies/markdown) ([Markdown](https://aitinkerers.org/technologies/markdown.md)) — 24 public demos
- [PaLM 2](https://aitinkerers.org/technologies/palm-2) ([Markdown](https://aitinkerers.org/technologies/palm-2.md)) — 116 public demos
- [RoBERTa](https://aitinkerers.org/technologies/roberta) ([Markdown](https://aitinkerers.org/technologies/roberta.md)) — 118 public demos
- [Aider](https://aitinkerers.org/technologies/aider) ([Markdown](https://aitinkerers.org/technologies/aider.md)) — 3 public demos
- [Code Auditing](https://aitinkerers.org/technologies/code-auditing) ([Markdown](https://aitinkerers.org/technologies/code-auditing.md)) — 2 public demos
- [Keras](https://aitinkerers.org/technologies/keras) ([Markdown](https://aitinkerers.org/technologies/keras.md)) — 74 public demos
- [Momentum](https://aitinkerers.org/technologies/momentum) ([Markdown](https://aitinkerers.org/technologies/momentum.md)) — 2 public demos
- [Ollama](https://aitinkerers.org/technologies/ollama) ([Markdown](https://aitinkerers.org/technologies/ollama.md)) — 75 public demos
- [ONNX](https://aitinkerers.org/technologies/onnx) ([Markdown](https://aitinkerers.org/technologies/onnx.md)) — 83 public demos