nice pattern with the stored queries for writes. but who defines them? if the app author can create their own stored queries, the write restriction is basically honor system.
so the 11% miss rate - do users actually notice when the agent drops a memory? like if someone already said they tried X and the agent suggests it again.
review agents have the same training biases as the one writing the code. you get 30 findings about error handling and edge cases, but wrong domain assumptions slip right through.
the bigger problem is agents defaulting to the broadest command possible. kubectl get -o yaml when a jsonpath query would give 1/50th the tokens. filtering after the fact works, but you're still paying for the round trip. better to teach the agent to ask narrow questions in the first place.
allowlisting breaks once the agent has messaging tools. you can deny all outbound from the agent, but if it can post to teams or slack or email, link previews will fetch whatever URL the injection puts in. messaging is usually the first tool anyone adds to an enterprise agent so you end up with strict network controls that don't actually prevent anything.
I built a vibe coding replay/inspection tool https://vibe-replay.com/
I built a co-work for cursor, I haven't publish that yet
I also built something combined activity watch and screen pipe, that provide `what did I do` context to LLM, this one didn't end up very well, still an interesting exploration though
investigation is the hard part, not generating patches. we've had prod issues where the fix was obvious once you knew the cause, but finding the cause meant connecting an error trace to a config change from 3 deploys ago. if the MCP only surfaces traces and logs from one service the agent is going to propose workarounds instead of actual fixes. how deep does the investigation context actually go?
they say it themselves in the post - behavior dimensions "not well captured by existing benchmarks". that was the exact problem with composer 2. not dumber on individual tasks, just bad at session-level decisions like when to stop editing, how much context to carry forward, when to re-read a file vs assume. you don't catch any of that in an isolated eval.
i've made maybe 20 personal LLM tools this year. 3 survived past the first week. not because the rest weren't useful, just wasn't willing to debug them when something broke.
maintenance cost on AI code isn't really uniform per line. most of it follows standard patterns, maybe easier to maintain than average human code. but the 5% where something went subtly wrong costs way more to fix because you can't retrace the reasoning, you just re-derive the whole thing from scratch. average looks fine but the tail kills you.
is there any data on how many Actions minutes a single copilot review actually takes? the announcement doesn't mention it, and for a team doing 20+ PRs a day that number adds up fast.
same issue from the other side. when a human is editing, the LSP fires mid-keystroke and shows bogus errors for a second, whatever. with an agent doing 5 edits in a row, the symbol DB is always behind by one edit, so the next lookup pulls stale references. you can re-index synchronously after each edit but that kills the batching speed.
the scan catches surface stuff. funnier signal would be tracking when the agent reads the same file 3 times in a row, or deletes what it just wrote. you can hear the frustration in the access pattern.
atomic commit with the business data is the selling point over separate IPC. external message passing always has the 'notification sent but transaction rolled back' problem and that gets messy.
one thing i'm curious about: WAL checkpoint. when SQLite truncates WAL back to zero, does the stat() polling handle that correctly? feels like there's a window where events could get lost.
the async transport feels like the wrong layer to optimize. biggest issue i keep running into is agent session state being completely non-portable between tools. Claude Code dumps JSONL, Cursor splits data across SQLite and separate JSONL files, and none of them agree on schema or even what counts as a "turn". you can make the message bus async but if you can't reconstruct what the agent did from its own session data, that's the actual blocker. i'd rather see a shared session format than another pubsub layer.
The monthly cadence is what makes this work. I recognize the feeling of having ideas rot in a notes app because you keep waiting for the "right" version - a fixed shipping rhythm kills that problem.
Favorites: VandalAds (the spray-painting origin story you mentioned makes the whole concept click) and Slow Internet Simulator (there's something real about nostalgia for imperfection). Trip to Mars at 210 real-time days is also wild - has anyone actually completed it?
The single HTML file as a distribution format is really underrated. No server, no CORS issues, no CDN — just open the file. It works offline, you can email it, and it'll still work in 10 years.
I ship self-contained HTML files for a different project and the sneakiest gotcha is </ sequences inside inline <script> tags — the browser sees </ and tries to close the script tag prematurely. You have to escape them as <\/. Curious if the author ran into that one.
Fun concept for the format too — games are the perfect use case.
Claude code on the other side is much more cleaner, also made build tool on top of it really easy. I have a deep dive in Claude code local sessions as well, I believe many people have done it already
As everyone probably already know, cursor is not really local first, a pretty significant part of logic is in their server env, yet their local storage still can provide some information. Their data are spread between SQLite and JSONL, depending on whether you use a dev server or container you may have various level of informations
A PR tells me what changed, but not how an AI coding session got there: which prompts changed direction, which files churned repeatedly, where context started bloating, what tools were used, and where the human intervened.
I ended up building a local replay/inspection tool for Claude Code / Cursor sessions mostly because I wanted something more reviewable than screenshots or raw logs.
My main frustration with long-context coding sessions isn't just the limit itself, it's that after the fact it's hard to tell which turns
actually caused the context to bloat or the session to go off track.
It's painful enough I have to build a tool to help myself understand the context/turn data correlation. I have to manual compact now