I just added Clocking In to Trunk Sync.

Now, Claude sessions are automatically aware of each other so they can better avoid and manage conflicts over files and other resources.

Many agents can work in parallel without any additional effort from you to integrate their output. It doesn’t matter if they are on OpenClaw, worktrees, or just running on local main. Everything stays in sync, agents work around each other, nothing gets left behind, nothing manual to do. If you’re confused about some code, you can summon the author with Seance.

Really happy with what I’ve been able to make Git do using Claude hooks and a little CLI. I’ve built a distributed file system for multi-agent SWE with some good and unique features.

Check it out here: https://lnkd.in/gWgaTwdP

With Seance you can turn any line of code into an interactive session with the coding agent responsible rewound to right after it did the work. It’s like reaching back in time to grab the original programmer just as they were writing the code and demanding they explain themselves.

Example here: https://lnkd.in/gJpW8qke

Lots of people are talking about how gen AI has brought XP to the fore, but I haven’t heard much discussion of why.

In my experience, many people simply didn’t try XP. They were locked into a tightly controlled environment, discouraged from experimenting, and constrained by process interdependencies. Maybe they didn’t have the influencing skills to get the rest of the team on board – it’s not easy to drive bottom-up change.

Did AI dev speed made experimentation simple and fast enough that anybody could try different workflows and observe the results?

Imagine a starting point – whatever you’re prepared to specify up front about your software. Then far to the right on the x axis imagine a solution. It’s perfect software – exactly what you needed.

Claude doesn’t know how to get from here to there in a straight line. It’s going to do a lot of trial and error – try a few things until something works. At each decision point, Claude might be moving up or down the y axis on its journey along x towards the solution.

Part of this vertical movement is produced by a dangerous fear of crashing: ‘What if this obviously intrinsically necessary field isn’t provided? I better engineer a crazy fallback.’ Anthropic this is my number one problem with Claude Code. Another contributor to extra complexity is that Claude makes confident guesses until it’s right and then moves on; typically the first thing that works is suboptimal.

This is software engineering as a combinatorial expansion of the guesses that happen to work into code, over time and tokens. At the end you have this kind of zig-zagging line – more complicated than it needs to be, but proven working. I think *overfitted* is the right word for it.

How are you managing this? For me, with one arm (session) I’m extending and with the other I’m pushing the weird adventures on the y axis back toward the most direct route – simplifying.

“Cattle, not pets” was a good phrase for helping people understand Phoenix servers, Infrastructure as Code – that whole concept. I like it a lot.

An equivalent for working with AI right now:

“Factories, not conversations.”

You are building a factory for producing output. If the output isn’t good, improve the factory. If you don’t like what it produces, arguing with the last person on the production line won’t help much.

I’m sharing again – this time a bit more fun.

Some issues I’m thinking about lately:

• Non-technical people vibe coding and frustrated by Git
• Very technical people running many agents in parallel and frustrated by Git
• Forward-thinking people running multiple agents in the cloud, and having them get stuck with uncommitted code
• The usual big-batch problems (see some of my classic topics: XP, CI etc.)

With all that in mind, here is a fun experiment: Trunk Sync. It’s maximum continuous integration for coding agents.

It keeps main and Claude-created work trees (claude -w) in sync with your remote trunk. Agents discover conflicts on write, resolve conflicted files and continue. Conflicts are resolved the same way between work trees, different hosts – it doesn’t matter. It’s just using Git and integrating on every file write.

Repo is here https://lnkd.in/gTCf6pSw and your agent can install it for you. Good example of it working here: https://lnkd.in/gpYe4X3t

Use with caution – understand this is an experimental approach and you will not be able to control what gets pushed.

Trunk Sync is extreme continuous-integration https://lnkd.in/gTCf6pSw for Claude Code. Easy agentic conflict resolution on write, keeps work trees, remote agents, everything aligned per write, using only Git.

I’m quite enjoying this – it was a deliberate jump out of my comfort zone (until now I kept commits under human control and resisted machine commits).

All my work is heavily tested, but naturally I am not running the whole suite on every file write – the main risk seems to be building atop an already broken build, which you could do very fast this way. So far so good, though.

The narrative goes something like: AI is pulling the ladder up for junior devs. Seniors are multiplying their value. The gap is widening.

I spent ten years dragging many of those seniors out of Gitflow. They’re not all thought leaders on LinkedIn – they spend half their time navigating org charts. TDD was too wild for them, XP just a naive dream. How many will adapt fast enough?

Even people prepared to change are constrained by orgs that aren’t. Most orgs are trying to fit AI into existing structures instead of rethinking them. Untangling the gordian knot of each org takes great leadership, effort, and time. How many will adapt fast enough?

This is the great flattening. The next generation doesn’t need a ladder to waterfall thinking, sprint planning, and 3 square meetings a day. They don’t need narrow roles, outdated processes, or $30M in seed funding. They don’t need to adapt – only grow. They can just build things for people.

It’s the orgs pulling up ladders that should be worried.