Since the release of GPT, I have found that the hassle of efficiently using keywords to search for hidden information on Google has been replaced by GPT search. Artificial intelligence should become a powerful assistant, but we cannot give up our own abilities.
I kept hitting the same failure mode with AI coding agents: the chat “remembers” a layout that moved, queues stop collapsing, and tests stay green while checking nothing.
We paid for those lessons on two live projects (Framefinity and Sonoscope). The durable fix wasn’t better prompts — it was an operating system: repo as sole authority, write-once sync cards (filename is the claim), counter-last, delete-on-close queues, and gates whose selftests include deliberate expected-red cases.
Tandem Start packages that into a small demo project you can run through end-to-end in about 30 minutes (first sync + selftests). Free essay on the scars is the link above; the kit is here if useful: https://bescript.gumroad.com/l/tandem-start?offer_code=TANDE... ($49 list / $39 intro).
Happy to answer anything about the failure modes or the gate design.
The snapshot/restore detail is the most interesting part to me. If artifacts really suspend to storage after inactivity and restore on next access, that's the same bet Fly.io made with Firecracker machines, and it mostly worked once restore times got under a few hundred ms. I'd love to see the author measure actual restore latency across artifact sizes, because that number decides whether this pattern can replace always-on preview environments. There's also a cost angle worth digging into: per-session ephemeral VMs are cheap to suspend, but storage and restore I/O for big node_modules trees add up fast at scale.
I am currently developing a great encryption tool for long-term highly confidential files in the post quantum era, but I am still concerned about any issues with it, so I am personally using it for a period of time to prove that this tool can be released as open source! (I plan to personally use it to encrypt and backup some of my GPG keys offline, then burn them onto M-DISC discs and store them in a bank safe)
Built a small free thing this week: a "Spreadsheet Triage Checklist" — 7 common ways ad-hoc spreadsheets quietly break (stale copies, silent formula errors, no version control, etc.) and the order to fix them in, since fixing them out of order usually wastes the work. Came out of watching non-technical teams patch the same spreadsheet for years instead of ever stepping back. Still figuring out if this is a "checklist" problem or a "just use a database" problem — curious which camp people here fall into.
I use Zed (https://zed.dev) as my agent harness and either the $20 ChatGPT sub + Sol for personal/independent projects or an enterprise Claude account for sponsored/paid work. From the stats for my current work I use about $400/mo in tokens and a lot of that is non-coding work like pruning JIRA, managing business documentation, making dashboards - so my true coding agent cost is significantly less.
It's pretty simple, you could probably set up something like that by:
Configure some kind of CLI tool to talk to your ticketing system and git repo so you can programmatically interact with them. If you don't have a ticketing system, instruct the agent to use local text or markdown files to track issues and progress.
Ideally, make your code runnable in a way the agent can use. For my webapps I build a test harness so that I can run all the endpoints and workflows via reproducible tests against an embedded database. This is easier than it sounds, e.g. there are libraries out there to embed PostgreSQL or SQLite into source code, you can set up a test harness so you can run unit tests, integration tests and workflow tests that use your real frontend, server and database.
Paste this comment thread into the agent prompt and tell it to run a similar loop on your code base: a session that searches for vulns and writes up a report, some way for a human to do a review pass on the report, a session that indexes the reviewed findings into tickets, and sessions that fix the fixable issues and submit patches to your repo. The next search session should first read all the open issues so it doesn't duplicate work of earlier sessions.
LESS IS MORE - avoid fancy agent tooling and skills, don't cargo cult from others, build your own tools as you find your own needs. If something can be automated, use the agent to write tools and tests for it, don't just keep prodding the agent to do it.
I used to ask this question back ~2015 - I was seeing companies with massive, clunky CMS installs just so their non-technical/less-technical staff could update their websites without filing tickets to IT/dev. It seemed to be more about those departments wanting autonomy and not having to wait weeks or months for internal IT/dev to make site updates. The consensus within one dev group was that the company would have been better served by hiring someone who knew HTML/CSS/Javascript to embed with the non-technical people and edit a straightforward frontend site for them.
I mean... you can literally do that now. You can set up a loop to iteratively pentest, review and patch a codebase (with human supervision as you prefer) and it'll find and fix more vulnerabilities in a day than a pentest team used to find in a quarter, for a tiny fraction of the price.
This isn't a joke, this is now part of my pre-launch SOP. I even have it tracking everything so I can log stuff to fix vs. known shippables vs intentional design/false positives vs. upstream stuff which doesn't have a fix available yet, and keep track of which builds have the fixes. Almost entirely automated, I mostly review the findings and do some categorization/enrichment during the pentest review stage, and do a human code review pass as patches are submitted.
Stuff that used to take me multiple hours to write a fix for and then weeks to get code reviewed and deployed now get done in minutes.
Glad it was useful! The full 10-item checklist is at merlin-ship-checklist.surge.sh — rollback testing and webhook test items have the most real-world notes.
a tool that actually shows what third party SDKs in your own apps are phoning home to would be huge, most people have no idea what their own dependencies are sending out. everyone builds network level tools but that app level visibility is missing.
most of the pain at scale isn't the agents themselves, it's observability. once you're past a handful you basically need per-agent tracing or you're debugging blind, worth borrowing tooling from how people do this for microservices
The language syntax is pythonic. This is not a superset of python. Interop for sere/python isnt official yet. Right now interop for C/C++ does exist and works well.
Now: Fable 5.1 medium effort for heavy computational (evolutionary) biology and everything else on the $100/mo max plan. It's great.
6mo from now: deepseek assuming the US AI industry insists on self-pwning.
I’ve been building Sere, a statically typed compiled language that tries to combine Python-like syntax with lower-level capabilities you’d normally associate with C++, Rust, or Zig.
The core idea is to keep everyday code simple:
def main() -> i32:
print("hello from sere")
return 0
while still allowing things like structs, enums, generics, native interop, and explicit memory control when needed:
Sere currently compiles through LLVM and produces native binaries. I’ve also been working on the surrounding tooling, including a language server, VS Code support, project tooling, library packaging, and C/C++ interoperability.
This is still an early project, and there are definitely rough edges. I’m posting it here because I’d really like feedback from people who work on compilers, language design, LLVM, systems programming, or just enjoy trying new languages.
I’d especially be interested in feedback on the language design itself, what feels unnecessary, what feels missing, and whether the Python-like syntax works well once the language starts exposing lower-level features.
One thing interesting about the Church is that Kings, Inquisitors, Revolutionaries, Govts etc have all tried to break the seal of confession for thousands od years now. The Church has some how managed to defend it by saying we believe path to repair/forgiveness involves creating and maintaining space where people can confess their sins. If a priest shares those sins with the state, everyone looses trust in the system and therefore breaking the seal over any sin is equal to dismantling the institution itself. This argument is literally the same structure used to defend attorney client confidentiality, psychiatrist patient confidentiality, corporations(telcos, email providers, platforms) from handing all data to the state.
But for all those cases the state has manahed to add huge amount of expceptions which it has not been aable to do with the Church. So the Churchs defense of the seal almost since 1215 has stood on a Belief. A story literally. That privacy is requires for repair.
Everyone else just hasnt come up with a good enough story.
Secondly what is stored in the head of a priest is usually forgotten cuz human memory is flaky and no one is writing anything down in a central db. So every now and then a state attack on the seal work but the everything then reliea on how reliable the memory of a single priest is. Its like a terrible distributed atorage system that is constantly forgetting things. Notice this is literally what large platforms have now built to defend privacy. Its called data minimization and costs a huge amount that they constantly cry about.
So its really funny how the church just stumbled into a solution that is cheap and hard to attack.
They invented self-healing concrete far superior to anything we use today and it took us 2000 years to realize we’re really smart morons. Romans built things to last, we build it to crumble.
To be honest, aside from medicine and whatnot, what real benefit is AI bringing?
I use it to accelerate my development and it’s great, but as far as this is concerned, how many vibe coded apps do we need as a society? And for the quality of information it’s a junkyard overflowing.
I built a strategy agent and ran through a bunch of ideas, positioning them etc. even though the AI has a good sense of that, and for a moment I believed it to have good direction, man I was mislead. I took a step back and realized this thing has NO FKING IDEA. It almost derailed me and what I need to be doing. It was very convincing and took introspection to get back on track.
Its creative writing skills are idiotic and it’s emotional intelligence garbage.
It’s a bubble everyone and save for medical advancements, the rest is a mirage. Even if companies accelerate some temporary economic advantage, the real tangible value to humanity seems to be few and far between.
But it’s cool and everyone is masterfully debating the next big model advancement.
This. When it's a person the original quote applies. But big companies have millions of data points on everything and are competent in areas they care about like their own profit. So you can assume it's not ignorance. They don't care if a publisher has to spend loads of time resolving issues rogue ads and malvertising because it doesn't affect them and the end user just blames the publisher.
Last year, Mozilla released Orbit, an AI-powered browser summarizer hosted on a GCP server. After people started digging into the extension, they discovered things like backend endpoints such as store_result. Eventually, Mozilla discontinued the project.
For the past month, I’ve been trying to rebuild Orbit from scratch, but with one major difference: Apogee is fully local and privacy-focused. Apogee doesn’t send or store your data. It can directly connect to your local Ollama instance for inference. I’ve also added WebGPU integration for Chrome and Transformers.js for Firefox to provide faster, local responses.
It can summarize: Articles and websites, YouTube and Billie videos, Wikipedia articles, Hacker News and Reddit threads.
