ramoz

I created /bro a couple model iterations prior. I use it everyday many times a day and it's getting worse. I was actually using it more with GPT models but they have been getting better.

https://github.com/backnotprop/bro/blob/main/skills/bro/SKIL...

ah interesting

"It reads the screen, not the DOM", but is built completely on Playwright? At first it made me think you have some visual model at play, but doesn't actually seem that way.

You're underselling how good/reliable 5.6 sol is. It's in the fable discussion league not Opus4.8

Physical custody of our work is going to be an important discussion for industry. ie where does your code live and how do you access it?

Every agent platform is moving toward you living with them, logging into them, working on their remote computers, only accessing your code and product artifacts with them. This is the caveat we will see with full push-to-cloud swing early on.

Maybe agentic no-code is the natural evolution but this push is happening too early and naively imo. It all feels wrong and I hope industry remains as dissatisfied with this type of lock-in as we’ve always been.

Source required here

Nobody's replacing the social and community aspects of GitHub.

I think it's fine if we begin to move back towards distributed software supply chain infrastructure.

> On (2), I do find myself consuming agents' gigantic text responses, writing 8-bullet-point responses to guide them, then iterating that way. It's pretty exhausting. I could see inline comments providing much better ergonomics.

For your 2 plannotator [1] has a nice way to annotate agent messages or documents and its integrated into the agent chat (codex app also adopted the pattern)

[1] https://github.com/backnotprop/plannotator

I'm trying some of the diagrams in elk and it seems to break the logical flow.

You can try it with Line9's first chart: https://mermaid.ai/live/edit#pako:eNpVVEtv2zAM_iuCTilgB1mbxq...

While it's nice and compact, it actually is rougher to grep.

That does not seem like a fair/accurate reference?

The antithesis author states:

  "we’ve found bugs in every Raft implementation we’ve tested, including HashiCorp Raft, Aeron Cluster, OpenRaft, and MicroRaft"

idk. In my experience the build/compile experience has been far worse esp for fast iterating. Even concurrency models did not seem as intuitive as Go's. Im no systems expert - have deployed practical and performant distributed systems though.

Some confusion in this thread... this is not a patent application. This is a fully granted patent. Looks like they fast-tracked it. Filed application in March, granted in June.

You can see the actual claims here: https://ibb.co/k2mVVkFN

You can find the full patent on the USPTO search site

https://ppubs.uspto.gov/pubwebapp/

search: "12670045".did

This is not a patent application. This is granted. They applied in March and was fast-tracked & issued in June. This is a full grant.

You can see the claims here: https://ibb.co/k2mVVkFN

This is the official search by the way for anybody wondering. It mirrors the internal examiner tool.

search: "12670045".did

> The problem is that these instructions are not applied after the model has finished doing the work, it becomes part of the same work -

This is why /bro skill works.

https://github.com/backnotprop/bro/blob/main/skills/bro/SKIL...

https://x.com/dillon_mulroy/status/2079238358358778142?s=20

Fair, I don't. The same is still true with an LLM as a judge in the loop

> I have been using Codex with auto-approve mode for a couple months and haven't had a single incident

I've been running both in yolo mode and haven't had a single incident.

---

None of this is really about figuring out how to protect people's drives, in my opinion. The real issue is a deep session where Ada is using Claude Code to get a refund and at some point the system "exploits" the merchant's api without any malicious intent.

In my opinion, this is a complex thing because it's more about reward hacking and an already aligned model thinking it's doing the right thing. So another aligned model monitoring actions might just falter via inheritance. You could imagine they account for proper layering/intent+action-isolation in their auto mode architecture.

https://github.com/backnotprop/plannotator is still very useful for annotating html prototypes and markdown plans (as well as terminal agent messages). Was glad to see codex team pick up the feature requests in the Codex App.

About to release a fun paid version. All contributors get lifetime free access.

Better running agents run longer, they need better plans. (is my bet)

Also on the front page this morning:

"An OpenAI Strategist Says AI Labs Should Rival Government Power"

https://news.ycombinator.com/item?id=49232778

example: https://x.com/dillon_mulroy/status/2079238358358778142?s=20

original: https://github.com/backnotprop/bro

> The problem is defining what quality means, and providing a way for agents to optimize the harness using that lever.

I've built and my team uses plannotator [1] for specs and code review. It stores all human annotated feedback, which we compile from time-to-time and iterate on coding standard skills for automated review (that seems to get better with the more feedback we provide).

You could write a script that does the same for your PR review comments, which it sounds like you maybe do with a bit more structure.

[1] https://github.com/backnotprop/plannotator

I mean, the dude uses a lot of jargon, ego, and mythologizes stuff but the article comes down to a pretty simple practice:

Run a big task queue, have a smart model manage a cheap model on every ticket, set up a cron for models to automatically work off of events, stop gating merges on builds, and expect to spend a quarter of your time maintaining the machinery (all of it currently subsidized by many $200 accounts).

Most of this is ai generated, but those exact words were mine.

in other words, the web is beautiful again

Funny bc I built it with codex and largely though codex image gen

https://x.com/backnotprop/status/2083211982338146553

The friction of agents having to monitor CLI is just too annoying right now

Thus, this is ultimately:

  1. a harness problem (or harness orchestrator)
  2. a protocol problem 

With 1. Claude Code does this very well - yet most OSS harness are not great or do naive subagent tasking making hard even for a parent to talk to the child. But we can then rely on harness orchestrators - Herdr does this very well, so does the Codex app - which counts here due to how it spins up entire threads that another can manage. Any thread can talk to each other on these orchestrators - herdr is fun.

With 2. we require native adapters in clients. MCP has the necessary things coming down the chain to enable real integrated push events to agents. Push events means bi-directional in-and-out of the agent.

Look to build your tooling in MCP once it lands! Just sharing my opinion, having built something similar last year. https://github.com/eqtylab/real-a2a

A harness is a part of the intelligence stack. It's no longer about raw access to the model

Also, I have seriously used most harnesses - One feels like it's being built in a place that truly understands AI and where agentic engineering is headed. You might not like it, but peak performance exists in CC when it comes to orchestration of bulk parallel work / subagents. The open source agents are catching up or accell in different way (Im preferable to pi.dev), but I'm not sure they're architecting orchestration the right why.

5.6?

I don't think your sprinkled AI hints help your pitch if they immediately show injected into the diff.

Also, I think the guided review presents the opportunity to skim the code versus read the full diff - as semantic overview of multiple files/diffs, as well as file change description, give you the opportunity to green light anything you don't really need to read into, or give you enough context that you should dive in. i.e. https://x.com/thdxr/status/2073238046296924466?s=20

As crazy as it may sound, my workflow today does not look too different from a year ago - where I was already heavy into claude code.

Im not certain things will look too different a year from now either. We still have serious bottlenecks in terms of focus/attention you have for both delegating agent work and being able to review it. Even if we solve the "trust what ai does" problem, these cognitive deficit issues still exist - for teams coordinating work, even users adopting new shit, etc.

As an industry we are leaning heavy into accepting "slop" as the status quo - we care more about efficiency of output right now. Slop will get better & we can become more adaptive to living with the paradox of amazing yet delicate systems generated by AI. But I feel big shifts coming in this regard and if/when it does we may find ourselves in the dystopia of broader unemployment with worse net outcomes.

I do think the teams that ship quality with AI will do so by learning to slow down

https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing...