Heddle
Version control for agent work that tracks tasks instead of commits.
Tagline
Version control for agent work.
Drop in beside Git. Track tasks, not commits.
The control layer for agent-authored code.
Every AI change reviewable, recoverable, attributable.
Heddle is the missing control layer for agent-authored code, sitting on top of Git.
This is the cleanest category-defining claim on the page: it repeatedly says 'Keep Git' and 'Drop in beside Git,' while showing that Heddle adds task threads, review, and provenance instead of replacing the repo.
The alternative to branch chaos, stash loss, and commit archaeology for AI coding workflows.
The landing page directly attacks git stash, cherry-pick, push --force, and blame. That gives Heddle a strong 'stop doing X' narrative that maps to the exact pain of agent-driven branch sprawl and lost context.
For teams shipping with agents in production, Heddle makes every AI change reviewable, recoverable, and attributable.
The product story is not generic productivity; it is specifically about review, recovery, attribution, and signed merges for agent tasks. That makes it a pain-killer for teams already using autonomous or semi-autonomous coding agents.
Primary user
Engineering leads managing multiple AI coding agents in a production Git repo
ICP #1
Engineering manager at a 20-100 person SaaS company using Claude Code and Cursor in production repos
Pain
They cannot tell which agent made which change, what was tried and abandoned, or whether a diff is safe to merge without reading a pile of chat logs and branch history.
Why this solves
Heddle turns agent work into a named task thread with delegated-by metadata, review state, tests, and signed merges, so the manager can inspect one object instead of reconstructing intent across commits.
ICP #2
Staff engineer owning developer experience and monorepo workflow at a fast-moving product team
Pain
Parallel agent work creates branch sprawl, lost context, forced rewrites, and messy handoffs between tools like Cursor, Claude Code, and Codex.
Why this solves
Heddle's fork, retry, and recoverable thread model preserves every path and lets multiple clients converge on one repo layer without forcing a migration away from Git.
ICP #3
Security-conscious CTO at a startup shipping auth, infra, or compliance-sensitive code
Pain
They need provenance, signed changes, and a clear audit trail for AI-generated code, but Git blame and commit history only tell them who last touched a line, not which agent produced it or why.
Why this solves
Heddle records object-level attribution, confidence, delegation, and ed25519-signed merges, which gives a much stronger audit story than ordinary Git metadata.
Strengths
- +The page is extremely specific about the job to be done: task threads, forks, signed merges, object-level attribution, and cross-client capture.
- +The 'Five Git rituals you can stop doing' section is a strong wedge because it translates abstract infrastructure into familiar developer pain.
- +The product demo content is concrete and credible, with real-looking task names, timestamps, signatures, and review surfaces.
Weaknesses
- −It assumes the visitor already understands agentic coding workflows and Biscuit capabilities; a lot of the copy will be opaque to non-experts.
- −The page leans heavily on conceptual diagrams and workflow rhetoric, but it still does not clearly show the exact UI or the day-to-day interaction model.
- −There is almost no proof of adoption, customer logos, or quantified outcomes, so the claims about review/recovery/control feel unvalidated.
- −The use cases are strong but narrow; the page speaks most directly to backend engineers and auth-heavy teams, which may underplay broader applicability.
- −The CTA 'Get access' is vague and the form asks about 'where agent work currently break[s] your review or recovery process,' but the landing page does not preview what happens after submit.
Fix these
- Add a crisp 'How it works in 3 steps' section showing init, capture, review, and merge in the actual product UI.
- Introduce one or two real customer stories with before/after examples, especially from teams using Claude Code or Cursor on production repos.
- Make the security/provenance angle more explicit for CTOs and platform teams by explaining signatures, confidence, and auditability in plain English.
- Create a dedicated comparison section against GitHub PRs, worktrees, and ad hoc branch workflows to sharpen the alternative narrative.
- Reduce the reliance on internal-sounding terminology like 'capture' and 'namespace' unless the page immediately defines them with examples.
Drop-in replacement copy
Headline
Version control for agent work
Track tasks, retries, forks, and signed merges beside Git.
Review the task, not the commit trail
Heddle groups agent activity into named threads, so reviewers see one unit of work instead of a pile of branches and chat logs. That makes AI changes legible fast.
Keep every abandoned path
Retries, forks, aborts, and conflict history stay attached to the same task. You do not lose context just because the first attempt failed.
Know who delegated what
Every object can carry delegated-by, model, client, confidence, and signature metadata. That gives teams a real provenance trail for agent-authored code.
Stay on Git without the chaos
Heddle is a repo overlay, not a Git replacement. Claude Code, Cursor, and Codex can all feed one shared control layer without a migration.
FAQ
Do we have to replace GitHub?
No. Heddle sits beside Git and GitHub. It adds a task layer for agent work without changing your source control system.
Does it work with Claude Code, Cursor, and Codex?
Yes. Heddle is built to capture work across those clients into one shared repo layer.
What if an agent run fails halfway through?
The failure stays attached to the task thread. You can retry, fork, or abort without losing the abandoned path.
How is this different from a PR or a branch?
PRs and branches are still useful, but they do not model agent work well. Heddle makes the task itself the object you review, trace, and merge.
Is this mainly for security teams?
Security teams will care, but so will engineering leads and platform teams. Anyone who needs reviewability, recovery, and attribution for AI code will feel the pain.
Git tracks commits. Agents don’t work in commits. They work in tasks, retries, forks, abandonments, and handoffs. Heddle sits beside Git and turns each agent task into one named thread you can review, sign, and merge.
Agent work breaks Git in a very specific way: branch sprawl, lost intent, forced rewrites. So I built Heddle: task threads with capture, retry, fork, abort, and signed merge state. Keep Git. Add memory.
If you need 12 commits, 3 branches, and a chat log to understand one agent change, your workflow is already broken. Heddle makes the unit of work a task thread, not a commit. That’s the thing you actually review.
Task starts in Claude Code. It fails. Heddle keeps the capture, marks the retry, preserves the abandoned path, and shows the review state in one object. No archaeology. No lost branch. No “what did this agent even try?”
Engineering leads don’t need another chat UI for agents. They need provenance: who delegated it, which model touched it, what got forked, what got merged, and whether the merge was signed. That’s the layer Git never had.
Heddle is a repo overlay for agent work. No migration. No replacing GitHub. No forcing your team onto one client. Claude Code, Cursor, and Codex all converge into one shared task thread per unit of work.
Blame tells you who last changed a line. That is not enough for agent code. Heddle records delegated-by, model, client, confidence, and signature so teams can trace why a change exists, not just who touched it.
When three agents work the same repo, branches stop being a workflow and become clutter. Heddle keeps every path browseable: captures, forks, retries, aborts, merges. You don’t lose the work just because the first attempt failed.
Claude Code starts it. Cursor retries it. Codex forks it. Heddle keeps the history in one place so the reviewer sees the actual path, not a pile of disconnected artifacts. That’s the unit teams need.
Can you prove this code came from the right agent and was signed before merge? That’s why Heddle exists. Object-level attribution and ed25519-signed merges are boring until you need an audit trail.
Angle: control layer over Git
Git was designed for humans making commits. AI coding agents do not work that way. They work in tasks, retries, forks, aborts, and handoffs. That mismatch is already causing pain inside teams using Claude Code, Cursor, and Codex in production repos. We built Heddle because the unit of work changed. Not the repo. Not GitHub. The unit of work. Heddle sits beside Git and turns each agent task into one named thread with capture history, review state, provenance, and signed merges. That means an engineering lead can inspect one object instead of reconstructing intent across commits, branches, and chat logs. If your team is already shipping with agents, you probably do not need another editor. You need a control layer. That is what Heddle is.
Angle: provenance and security
Most teams think the problem with AI-generated code is code quality. It is not just that. The real problem is provenance. When a diff lands, teams want to know: - Which agent made it - What model produced it - Who delegated the task - What got retried or abandoned - Whether the merge was signed Git does not answer those questions. It tells you who last touched a line. That is useful, but it is not enough for production agent workflows. Heddle records object-level attribution for each task thread and supports signed merges with ed25519 verification. That gives platform teams and security-conscious CTOs something much better than “trust me, it was in the branch.” If you are putting agents near auth, infra, or compliance-sensitive code, auditability is not a nice-to-have. It is the whole game.
Angle: workflow pain and recovery
There is a very specific kind of developer pain that only shows up once agents are in the repo. A task starts in one client. It gets retried in another. Someone force-pushes. A branch gets abandoned. The reviewer has no idea what happened. Now you are doing archaeology just to answer a simple question: what changed, why, and is it safe? Heddle is built to stop that. Every agent task becomes a named thread with captures, forks, retries, aborts, merge history, and review state. So abandoned paths stay browseable. Failed attempts stay attributed. The team gets recovery instead of loss. This is what git stash + git worktree add should have been for agent work. If your team is already fighting branch sprawl from AI coding tools, you do not need more process. You need a place for the work to live.
Tagline
Version control for agent work
Description
Heddle sits beside Git and tracks AI coding work as named task threads with captures, retries, forks, signed merges, and provenance. Use it with Claude Code, Cursor, or Codex without changing your repo.
Maker's first comment
I built Heddle after watching agent workflows turn normal Git habits into a mess. The code was fine most of the time - the problem was everything around the code: branch sprawl, lost intent, abandoned attempts, and no clear answer to who delegated what or why a diff existed. Git is still the right system for source control. Heddle is the layer beside it that makes agent work legible. One task becomes one thread. Every retry, fork, abort, and merge stays attached to that thread. Reviewers can see provenance instead of reconstructing a story from chat logs and half-dead branches. I’m shipping this for teams already using agents in production repos, especially those juggling Claude Code, Cursor, and Codex. If that’s you, I’d love blunt feedback: what’s still missing from the review and recovery workflow?
Pinned maker comment
I’d especially love feedback from teams already using agents in production: does the task-thread model match how you actually work, and what would make provenance/review trustworthy enough to adopt?
Meta
Agents broke Git in one exact way.
Targeting engineering leads at SaaS teams using Claude Code, Cursor, or Codex in production repos. Assumption we’re testing: they will switch from branch-based review to task-thread review if it removes archaeology, preserves failed attempts, and shows provenance in one place. Heddle sits beside Git and tracks agent work as named threads with capture, retry, fork, merge, and signed state.
Google Search
version control for agent work
Targeting people actively searching for agent workflow control, AI code review, or Git alternatives for AI coding teams. Assumption we’re testing: searchers want a repo overlay, not another editor or PR tool. Heddle tracks AI coding work as task threads with retries, forks, provenance, and signed merges across Claude Code, Cursor, and Codex.
Reddit Promoted
What git stash should have been
Targeting developers in teams already using AI coding agents and feeling branch chaos. Assumption we’re testing: they care more about recovery and auditability than another shiny agent UI. Heddle turns each agent task into a browsable thread with capture history, object-level attribution, and merge signatures.
Subreddits
r/SideProject
Share the problem: how agent workflows create branch chaos and why you built a repo overlay instead of another editor.
Rules: Show the build, the lesson, and the screenshots. No drive-by promo; explain what you learned and invite feedback.
r/indiehackers
Post a founder story about building a control layer for Claude Code/Cursor/Codex users and how you validated the pain.
Rules: Value-first posts do best. Avoid pure launch posts without context or numbers.
r/microsaas
Share the narrow ICP, the workflow pain, and how you’re turning one painful developer workflow into a product.
Rules: Keep it specific, technical, and useful. People here dislike vague SaaS marketing.
r/EntrepreneurRideAlong
Document the first 100 users journey and ask for feedback on positioning and pricing for engineering teams.
Rules: Progress updates and honesty work. Don’t pretend it’s bigger than it is.
r/programming
Only post if you frame it as a technical discussion on versioning agent work and provenance in Git workflows.
Rules: Self-promo is heavily scrutinized. Lead with technical insight, not product pitching.
Communities
Post a build log, then follow up with concrete screenshots, what failed, and what you learned from early team feedback.
Launch only when you have a crisp technical thesis and real product screenshots. Title it around the problem, not the company.
Claude Code Discord
Join conversations about workflows, not selling. Offer to compare notes on capturing agent work and ask for edge cases.
Cold outreach template
Hey {firstName} - saw {context} and thought of Heddle. It tracks AI coding work as task threads instead of commits, so teams can see retries, forks, provenance, and signed merges in one place. If you’re already using Claude Code or Cursor in production, can I show you the workflow and get a blunt reaction?
Product Hunt timing
Launch on Tuesday at 12:01 AM Pacific Time. That gives you a full U.S. workday for developer attention, enough overlap with Europe in the morning, and avoids the weekend noise when engineering leads are less likely to dig into a new repo workflow product.
Indie Hackers post ideas
- 01I built version control for agent work because Git tracks commits, not tasks
- 02What we learned from trying to make Claude Code and Cursor share one workflow
- 03How I’m getting the first 100 engineering teams to care about provenance for AI code
Competitor alternatives
Current tone of voice
Technical, contrarian, and slightly poetic; for example, 'Agents don't work in commits. Why version their work like humans?' and 'What git stash + git worktree add should have been.'
Your kit is ready. Sign up free to unlock, takes 10 seconds.
7 more X posts · 2 LinkedIn · Product Hunt copy · ad hooks · 100-user playbook · landing critique