Heddle retweeted
I asked Opus to go on a bug hunt. It found 156 bugs to handle. Then I asked it to get the root cause of all of the bugs and they all traced back to just 17 root causes.
Run this prompt:
“Audit any patched and remaining open bugs in this codebase. Look for the root cause, not the smallest patch. Use the bugs as symptoms, some of them are likely related.”
ALT Identified bugs, grouped by root cause.
Heddle retweeted
I will start with this...
Agents must be able to cryptographically prove who they represent, what they’re allowed to do, and within what limits, while the human or organization behind them remains accountable. Without this, everything else in the agent economy stays fragile
Heddle retweeted
Old news actually from a bunch of days ago, but crossed that 15M. Enjoy a nice reset everyone. Landing in the next hour or so, go /fast.
Heddle retweeted
Hello people of Sol! I've reset usage limits for all ChatGPT Work and Codex users. Together with that, a quick update on GPT-5.6 Sol usage limits.
Over the past few weeks, many of you have told us that Sol was using your Codex limits faster than expected. To be clear, we have not reduced usage on any subscription plans.
We’ve been digging into what was happening and have landed several improvements. As a result, we expect your usage to last around 18% longer during typical use of Sol. Some of you should already see significantly larger improvements from today. Tomorrow, we’ll also restore the five-hour limit that we temporarily paused while investigating.
Here’s what we found:
- GPT-5.6 Sol is much more willing to work for longer, make additional tool calls, and coordinate complex workflows across tools and subagents. That makes it better at solving hard problems, but some tasks were using far more than we intended.
- Sol also works harder at the same reasoning effort than previous models. High on Sol can use more tokens than High did on GPT-5.5.
- Programmatic tool calling, also referred to as code mode, gives Sol much more flexibility to run tool calls in parallel or continue working while waiting. But it also led to more responses per turn, more cached input tokens, and higher usage than expected.
- This was particularly noticeable when Sol was waiting for tool calls to finish or running many web searches. We’ve improved how we handle both cases and are continuing to make code mode more efficient.
- The impact was also very uneven. The median user actually found Sol quite token efficient, while some power users working on harder tasks saw their usage drain much faster. We were very focused on average and median usage before launch and missed some cases where the long tail could use significantly more usage.
Sol is a significant step forward in what Codex can do, but capability and efficiency do not always improve at the same pace, and some issues only become clear once people are using the model at real-world scale. We should have recognized this sooner and been more upfront about it.
You keep pushing the frontier and we’ll keep improving efficiency and sharing updates as we go.
Heddle retweeted
I’m working on a brand new approach to agentic coding.
You have repos and worktrees and sandboxes and rules to try to keep agents separate and working on their own thing. It works but there’s an underlying cost.
I’m making a system that’s built around tasks. As you give your agents a task, they get a thread. A thread lets your agent work on an isolated copy-on-write worktree and gives your agents access to scoped discussions. If agents need to collaborate they can simply messages the relevant task-based discussion and that message will get routed to whatever agent(s) are also working on that task.
Say you have a new feature in progress. You have an agent build it out and leave notes on where it got stuck via the discussion (which can be connected to a specific file or line) and then when you review agents come in they immediately benefit from the complex context the builder already assembled.
You save tokens, time, and effort as agents can leave hints throughout your code without using markdown files that go stale or comments that agents skip when grepping.
This works across harnesses, and across agents. It can even let agents communicate in real time by letting agents poll for messages or directly steering the target agent harness.
Heddle retweeted
Did @mitchellh ever say what the new GitHub is? Or are we just in limbo still?
Heddle retweeted
Just launched Heddle on @launch_llama 🦙 — give it an upvote 👇 tools.launchllama.co/product…
Heddle retweeted
Been thinking about this, the server forcing a new session happens because the server has to be the authority of trust.
What happens when we let users leverage the hardware security they already have on their devices?
We can unlock things where the client side can be the authority, allowing the user to simply be signed in. Ephemeral keys can allow you to keep short lived sessions that your hardware module can auto rotate.
All those “Are you sure you want to delete this?” modals can be passkey gated to ensure it’s actually you wanting to do it instead of a pseudo secure popup.
Users can then mint subtokens without the server so they can give agents a scoped token to use. Need to revoke access? Any revoked token auto revokes children.
Heddle retweeted
Git is long overdue for a glow up. Check out heddle
heddle.sh
Heddle retweeted
Heddle.sh: open-source version control for AI agent work.
Gives agents persistent versioned memory across tasks (“what one agent learns, the next remembers”), isolated threads, signed history, and safe semantic merging back to Git. Annotations become durable context injected into future runs.
Public alpha • brew install heddleco/heddle/heddle • heddle.sh • github.com/HeddleCo/heddle
Would love you to try it as first user.
Heddle retweeted
This is why I built discussions into heddle. You can talk about the intent behind the code and then turn the result into an annotation that is attached to your code, not directly in your code, but it allows you do detect drift automatically by raising that context on code changes.
Heddle retweeted
The hard part about monorepos, navigating and separating them.
What if your monorepo was actually a namespace? Clone the whole thing in 1 command, can sync from the root, scope permissions and CI to specific parts, simple navigation…
The kicker, namespace-wide stacked PRs
Heddle retweeted
I’m building this, beta OSS cli is available!
Instead of grouping work by branch, you group it by task. You essentially want a strong query model where you can refer to a named task and get the exact session that created it and resume that.
Heddle attributes the user, harness, model, and session directly to the created code so a small query engine would be able to drop you directly into the right harness with the session loaded.
Brb, gonna add this to my list this week
Heddle retweeted
Git: lighter, faster, and smaller 👀
heddle.sh/blog/sley-vs-git
Heddle retweeted
maybe rebuilding Git from scratch wasn't such a bad idea after all 👀
ALT Chart comparing Git and Sley write-path command timings on small, medium, and large repo clones. Bars show median milliseconds for hash-object -w, write-tree, update-index --refresh, add -u, add one file, and commit-tree. Sley is faster on most commands with complete git-test parity in those areas.