
co-founder @herd_eco, Solana/NEAR eco veteran, prev @Dune @Clutter @Video_Amp
đşđ¸
Joined December 2008
- Tweets8.3K
- Following2.3K
- Followers1.2K
- Likes30.8K
Edward retweeted
signal is a great word for it. Recently I encouraged folks to stop thinking in terms of "loops" and more in terms of:
"forward pressure" - what causes work to start (crashes, bugs reports, performance issues, +100 things)
and
"backpressure" - how does an agent hill climb against an outcome (linters, tests, ai review/risk judge, canaries, feature flags, +100 things)
looping these toward a desired state rather than an outcome / artifact is a powerful mental model - forward pressure increases autonomy in what gets attention, backpressure increases autonomy in getting to a super high-quality solution
9 months ago, loops like ralph were primarily used to go from point A to point B in terms of functionality, but this is just one degenerate case of a more generic control loop:
- read desired state (e.g. no open bugs, or DB perf above X metric, OR "feature Y shipped", OR "all linter warnings resolved or explicity ignored")
- read state of the world (query systems, run linters, etc)
- decide if anything needs to be done (compare to policy / desired state)
(optional: approve decision)
- do the thing (code change, infra change, docs change, process change)
(optional: approval action)
- repeat
shouts out @0xblacklight for the original framing here at AIE back in june. same logic works for evolving the control loop itself
Edward retweeted
Agents like safe APIs and languages. That the reason why Rust is so popular with them. Rigor is more important than conciseness and elegance.
A side-effect of the durable coroutines for TypeScript is that it yields (npi) a safer API, with no way to use Promises nondeterministically.
I expect that will be the default API for agents in the future. Anecdotally, most human devs still prefer Promises.
Software is having its Industrial Revolution and itâs changing what matters in software frameworks. Todayâs frameworks were designed for the crafty carpenter, tomorrowâs are designed for mass manufacturing processes where rigor > conciseness.
Take foldkit vs react/solid, for example. You can argue that foldkit is more verbose or complicated for some use cases compared to the traditional alternatives, but everything doable in react/solid is also doable in foldkit. Everything doable in foldkit is not (or at least not easily or consistently) doable in react/solid because they lack the rigor of command+event state machines with story & scene testing. Getting that back isnât easy and is a substantial loss for agentic coding.
Before AI, there was the valid argument of picking what humans like best. Humans kinda suck at programming because we are constrained by our skills, taste and (lack of) discipline, so frameworks that worked in this era catered to the lowest common denominator of mass market human developers. While I agree that react/solid are powerful in the hands of humans, that simply doesnât matter anymore.
Whatâs best for humans does not necessarily translate to whatâs best for agents. Some tasks may indeed be âa bit harderâ with foldkit in human terms, but AI is capable of solving all of them in a few minutes, so who cares. Instead of bike-shedding philosophy and taste, just choose the more rigorous (and scalable) option. It costs you nothing and gains you everything.
Effect is another example of this. With AI, now everyone of all skill levels can use advanced programming techniques that are objectively safer and more scalable, but were out of reach for many human programmers. Or didnât appeal to the stubborn tastes of a particular person.
With humans now out of the way of technology adoption - I think itâs obvious that the following techniques are going to become way more commonplace:
1. State Machines
2. Functional programming
3. Declarative infrastructure
4. Test Driven Development
5. Domain Driven Design
6. Actor Systems
7. Rigorous API schemas
8. Type Safety and Formal Verification
9. Disciplined Operations (monitoring, on-call)
Alchemy is designed to bring these techniques together into a seamless experience for building and deploying applications of massive scale. It is the ârailsâ and âpartsâ of the ai software assembly line.
Edward retweeted
Alchemy đ¤ Rivet Actors (finally!!)
Self-host the open-source alternative to Durable Objects anywhere
And Sam has put so much care in to the Alchemy API for actors/DOs⌠I canât stress how excited I am for this
Next week's release of @alchemy_run is gonna be a banger.
Got Rivet, Effect Cluster, Archil, Daytona, Modal and E2B all coming.
Rivet and Effect Cluster will be deployable anywhere, distributed as swappable layers:
Edward retweeted
An analysis of Deno by @slicknet

ALT Denoâs impact on the JavaScript ecosystem was strong. It pushed Node.js to adopt more web APIs like fetch instead of creating their own, introduce a permissions model, and work to support TypeScript by default. You could argue that Deno also helped push TypeScriptâs popularity to new heights, reignited interest in all-in-one JavaScript toolchains (something that Bun, Biome, and VoidZero continued exploring), and pushed for improvements in V8 that would benefit all of its consumers.
In my latest newsletter I discuss why Cloudflare bought Deno and what we can learn from this.
newsletter.humanwhocodes.comâŚ
Edward retweeted
I think we need to stop treating agents as their own thing. You are 100% liable for what your agent does
Replying to @burcs
fwiw i think we will see a lot more of these types of 'attacks' happen
if you have a signup flow, it's worth assuming this is coming, rate limit the endpoint, put a challenge on the form, flag headless browsers
cloudflare makes this easy
Edward retweeted
the temptation to iterate on the tool you built to do your work instead of just doing the work is such a menacing form of procrastination
Edward retweeted
turns out you need to read the code
some things I often say to claude when doing perf optimization work:
> how do we rewrite this to better leverage data-oriented design principles
> can you replace those hash tables with a flat array? can we make the pointers an index into the array? can we pack the most commonly used data into upper bits of the index?
> caching is cope for a slow design. do not add caches and delete all existing caches. instead, redesign it to be faster
> should this be a structure of arrays instead of an array of structures?
Edward retweeted
Software is having its Industrial Revolution and itâs changing what matters in software frameworks. Todayâs frameworks were designed for the crafty carpenter, tomorrowâs are designed for mass manufacturing processes where rigor > conciseness.
Take foldkit vs react/solid, for example. You can argue that foldkit is more verbose or complicated for some use cases compared to the traditional alternatives, but everything doable in react/solid is also doable in foldkit. Everything doable in foldkit is not (or at least not easily or consistently) doable in react/solid because they lack the rigor of command+event state machines with story & scene testing. Getting that back isnât easy and is a substantial loss for agentic coding.
Before AI, there was the valid argument of picking what humans like best. Humans kinda suck at programming because we are constrained by our skills, taste and (lack of) discipline, so frameworks that worked in this era catered to the lowest common denominator of mass market human developers. While I agree that react/solid are powerful in the hands of humans, that simply doesnât matter anymore.
Whatâs best for humans does not necessarily translate to whatâs best for agents. Some tasks may indeed be âa bit harderâ with foldkit in human terms, but AI is capable of solving all of them in a few minutes, so who cares. Instead of bike-shedding philosophy and taste, just choose the more rigorous (and scalable) option. It costs you nothing and gains you everything.
Effect is another example of this. With AI, now everyone of all skill levels can use advanced programming techniques that are objectively safer and more scalable, but were out of reach for many human programmers. Or didnât appeal to the stubborn tastes of a particular person.
With humans now out of the way of technology adoption - I think itâs obvious that the following techniques are going to become way more commonplace:
1. State Machines
2. Functional programming
3. Declarative infrastructure
4. Test Driven Development
5. Domain Driven Design
6. Actor Systems
7. Rigorous API schemas
8. Type Safety and Formal Verification
9. Disciplined Operations (monitoring, on-call)
Alchemy is designed to bring these techniques together into a seamless experience for building and deploying applications of massive scale. It is the ârailsâ and âpartsâ of the ai software assembly line.
every product i use should just be a headless mcp, that feeds into an agent, where i never have to think about anything underneath.
except for our product, of course.
in our product, customers love the ui and love us very much.
we're special that way.
Edward retweeted
Every methodology eventually collapses into this one. The rest are just what we call it in the retro.
Edward retweeted
surely i do not need property tests
nothing bad will happen if i skip property tests
Edward retweeted
It has been 16 hours since I was able to update my deployments on Railway đ

































