@bbelderbos My favorite 'agent' (I'll assume you mean 'harness' here) is https://t.co/0lTDQyJxvd
I do second reviews using the pi-subagents module in "council mode" so it gets reviews from Claude *and* codex models.
In my spare time I've been jamming on my own orchestrator: a native SwiftUI Mac app built on pi-durable (of course!)
I just talk to one "chief of staff" agent. It delegates async to an agent lead per project, each runs its own subagents, they all talk to each other, and only the decisions that need me land in my Inbox.
Because it hands everything off, the chief is always free: I can keep piling on new tasks across projects mid-flight and it keeps them all moving in parallel.
It renders in-chat gen UI built from real native Swift components, Mermaid diagrams via a native Swift port of Pele + rich HTML inline.
Fun as hell to keep iterating! Thanks @badlogicgames 🫡
@willmcgugan I like Frank's Red Hot, but to be honest, it's more of a condiment that has a lot more tomato flavor than spicy. I think of it like a slightly spicy ketchup 😊
superlogical/rex will be a thunderclap in the atmosphere of user expectations.
> measure (on both sides) network properties and dynamically adjusting streams
> ... prioritize traffic for your focused terminal.
> Mosh/ssh/tmux can't do this.
i support this message, except that we/i also try to slot in juniors, cause we need high trust/agency people in the future as well.
not possible in all setups ofc.
Plugin authors: ":help dev-test-plugin"[1] describes how to use Nvim's own test framework in your repo/CI, using a small Makefile.
Further work is planned[2] where the end goal is to ship the test framework with Nvim itself.
[1] https://t.co/6SFwZqyhRN
[2] https://t.co/SebgiSQutK
Fractal detail: even after days of focused, AI-assisted work to prepare & merge "remote-ssh" ...
I discovered & implemented 20+ improvements touching security, job-control, rpc internals, :restart, UX, etc.
This was supposed to be a 15-minute adventure!
We're still so small but I'm loving the team we've got at Superlogical. They're so talented and kind and love their craft. It's a different era of software development and our expectations and practices reflect that. I want to share a bit about how we work.
First, everyone is trusted to push to main. We do machine-aided code review pre-push and human plus more machine-aided code review post-push. Limited to no PRs.
Culturally, we've all agreed that if we ever hire someone who we DON'T trust to push directly to main, then they probably aren't the right fit for the team (so far, not an issue).
Some common sense here: if someone is stepping outside their lane or comfort zone, we'll open PRs. For example, I'm pretty trash at macOS/iOS UI, so I'll open PRs for UI-affecting functionality and ask for eyeballs/help. But for business logic and internals, I push to main.
Second, everyone can cut a release. Our release process is fully automated and when you start a release (for any platform) it triggers a Slack notification and a 15 minute countdown.
The 15 minute warning is a final gate that allows people to review plus collaborate on a changelog. During that 15 minutes, anyone in the company can pause the release rollout. After 15 minutes, the train leaves the station. You can't override the 15 minutes (except to pause). It gives everyone a chance to step in.
Third, we avoid synchronization through fast remediation rather than through planning. The server and clients on various platforms ship features as fast as they can. We use post-hoc human review and AI-assistance to identify feature mismatches across products ("Windows has support for X and Mac doesn't." or "Mac and Windows differ in their behaviors for Y in this way.").
This avoids expensive "sync" meetings and coordination. We trust that producers of features are mindful of what they're producing and we trust that adjacent product lines will self-synchronize quickly. In practice, we see feature parity across platforms within 24 to 48 hours.
All of this works on mutual trust. It ONLY works with mutual trust.
Everyone at all times has to trust that they've got each others back:
1. Push to main only works if you fix your mess, or if you don't, that someone else will quickly but that you'd do the same (and generally in equal amounts).
2. Anyone can deploy only works if you trust everyone to cut at the right time, with the right changelog, and that people will respect the 15 minute timer.
3. Sync through fast remediation only works if you trust other teams will pick up and integrate your work quickly, which only works if you would too. It also only works if you are fairly producing mismatches (e.g. not constantly).
We've got a great team. I know we're still small and that these practices will change in many ways as we scale. But this is already a markedly different practice than what I would've done 15 years ago.
In general, we are building from day 1 on a foundation of mutual respect, excellence, and trust. And it's been awesome.
Exploring the state space of a complex single-page app.
This is a real guided Bombadil fuzzing campaign. Each star is a state. Larger and brighter stars are high-reward or outright bugs. The little space ships are individual runs discovering new stars.
the most import skill in 2026 is still being able to tell your agents "wtf is this crap, no, not like this"
if you stop doing that, you're basically fucked, despite what some devfluencers would like you to think.
I already see clear signs that who is refusing AI assistance for programming it is starting to lag behind in a significant way, where this means: they are living in a bubble where losing work will happen faster compared to the other folks.