Patrick Kerschbaum retweeted
Ryan Dahl just launched celld: self-hosted, distributed Durable Objects.
One SQLite database per cell. S3-compatible storage. No separate database cluster or control plane.
I looked at the architecture, tradeoffs, and where I’d use it:
flaviocopes.com/celld/
Patrick Kerschbaum retweeted
📣 The moment is here. 📣
TypeScript 7 is officially released! 7️⃣
devblogs.microsoft.com/types…
Patrick Kerschbaum retweeted
More and more people are asking me about testing resources so let's put everything I've written in one post. Bookmark, share, and, most importantly, please read these.
The True Purpose of Testing
epicweb.dev/the-true-purpose…
Developers often overlook the fundamentals and rush into writing tests without properly understanding what a test is and what is its function. No test is inherently useful just because it exists. Read this one to learn what makes it useful.
The Golden Rule of Assertions
epicweb.dev/the-golden-rule-…
There's a lot of debate over what makes a good test. In this one, I'm defining a short and objective way to grade a test's quality no matter the language or the tested system. This is, without a tinge of exaggeration, a game-changer in how you approach your tests.
Anatomy of a Test
epicweb.dev/anatomy-of-a-tes…
Let's talk about the building blocks that make up any automated test. From JavaScript to Go and Rust—these blocks power tests everywhere. Know your blocks.
Implicit Assertions
epicweb.dev/implicit-asserti…
Did you know there's a way to express expectations in tests without writing "expect"? Those are called implicit assertions and they are tremendously powerful because they help you express more by writing less.
Inverse Assertions
epicweb.dev/inverse-assertio…
Sometimes you need to assert that something did not happen. That can be tricky, especially if that something is asynchronous. The last thing you want are false positives. What you actually want is inverse assertions.
Making Use of Code Coverage
epicweb.dev/making-use-of-co…
Code coverage has been an ongoing debate in the engineering circles. Is 100% code coverage in tests good? Bad? When should you strive for it? Why do people say it's harmful? I'm answering all those questions in this one and giving you practical tips on when to use (and not to use) code coverage.
Good Code, Testable Code.
epicweb.dev/good-code-testab…
You've gathered by now that some code is easier to test than the other. But why? Let's take a look at the characteristic of code's testability, what defines it, what is its relationship with complexity, and how to make your code more testable.
What is a Test Boundary?
epicweb.dev/what-is-a-test-b…
Automated tests rarely involve your entire system (yes, even the end-to-end ones have exceptions). There's often a place where you draw the line. The boundary. Learn what it is and how to use test boundaries efficiently to focus on the exact behaviors you want to test.
Be S.M.A.R.T. About Flaky Tests
epicweb.dev/be-smart-about-f…
Flakiness is the scourge of reliability. If you've written a test before, you likely had experience with flakiness. But what is it at its core and what causes it? And how should you deal with flakiness?
Writing Tests That Fail
epicweb.dev/writing-tests-th…
You write tests for them to fail. We all enjoy a green CI, but the true value of tests is when they fail. What matters is when and how they fail.
Patrick Kerschbaum retweeted
you can outsource your thinking
but you cannot outsource your understanding
Patrick Kerschbaum retweeted
🎯 After years of building with Node.js, I've organized my hard-won knowledge into skills: a collection of best practices, workflows, and deep expertise my AI assistant uses to write code to my standard.
No more repeating myself on every code review. 👇
Patrick Kerschbaum retweeted
It is hard to communicate how much programming has changed due to AI in the last 2 months: not gradually and over time in the "progress as usual" way, but specifically this last December. There are a number of asterisks but imo coding agents basically didn’t work before December and basically work since - the models have significantly higher quality, long-term coherence and tenacity and they can power through large and long tasks, well past enough that it is extremely disruptive to the default programming workflow.
Just to give an example, over the weekend I was building a local video analysis dashboard for the cameras of my home so I wrote: “Here is the local IP and username/password of my DGX Spark. Log in, set up ssh keys, set up vLLM, download and bench Qwen3-VL, set up a server endpoint to inference videos, a basic web ui dashboard, test everything, set it up with systemd, record memory notes for yourself and write up a markdown report for me”. The agent went off for ~30 minutes, ran into multiple issues, researched solutions online, resolved them one by one, wrote the code, tested it, debugged it, set up the services, and came back with the report and it was just done. I didn’t touch anything. All of this could easily have been a weekend project just 3 months ago but today it’s something you kick off and forget about for 30 minutes.
As a result, programming is becoming unrecognizable. You’re not typing computer code into an editor like the way things were since computers were invented, that era is over. You're spinning up AI agents, giving them tasks *in English* and managing and reviewing their work in parallel. The biggest prize is in figuring out how you can keep ascending the layers of abstraction to set up long-running orchestrator Claws with all of the right tools, memory and instructions that productively manage multiple parallel Code instances for you. The leverage achievable via top tier "agentic engineering" feels very high right now.
It’s not perfect, it needs high-level direction, judgement, taste, oversight, iteration and hints and ideas. It works a lot better in some scenarios than others (e.g. especially for tasks that are well-specified and where you can verify/test functionality). The key is to build intuition to decompose the task just right to hand off the parts that work and help out around the edges. But imo, this is nowhere near "business as usual" time in software.
Patrick Kerschbaum retweeted
tl;dr Today, we’re announcing our new company @EntireHQ to build the next developer platform for agent–human collaboration. Open, scalable, independent, and backed by a $60M seed round. Plus, we are shipping Checkpoints to automatically capture agent context.
In the last three months, the fundamental role of the software developer has been refactored. The incredible improvements from Anthropic, Google, and OpenAI on their latest models made coding agents so good, in many situations it’s easier now to prompt than to write code yourself. The terminal has become the new center of gravity on our computers again. The best engineers can run a dozen agents at once.
Yet, we still depend on a software development lifecycle that makes code in files and folders the central artifact, in repositories and in pull requests. The concept of understanding and reviewing code is a dying paradigm. It’s going to be replaced by a workflow that starts with intent and ends with outcomes expressed in natural language, product and business metrics, as well as assertions to validate correctness.
This is the purpose of our new company @EntireHQ, to build the world's next developer platform where agents and humans can collaborate, learn, and ship together. A platform that will be open, scalable, and independent for every developer, no matter which agent or model you use.
Our vision is centered on three core components: 1) A Git-compatible database that unifies code, intent, constraints, and reasoning in a single version-controlled system. 2) A universal semantic reasoning layer that enables multi-agent coordination through the context graph. 3) An AI-native user interface that reinvents the software development lifecycle for agent–human collaboration.
In pursuit of this vision, we’re proud to be backed by a $60M seed round led by @felicis, with support from @MadronaVentures, @m12VC, @BasisSet, @20vcFund, @CherryVentures, @picuscap, and @Global_Founders alongside a global group of builders and operators, including @GergelyOrosz, @theo, Jerry Yang, @oliveur, @garrytan, and many others, who all recognize that the time is now to take such a big swing.
And we begin shipping today with Checkpoints, a new primitive that automatically captures agent context as first-class, versioned data in Git. When you commit code generated by an agent, Checkpoints captures the full session alongside the commit: the transcript, prompts, files touched, token usage, tool calls, and more. It’s our first crack at the semantic layer, as open source CLI on GitHub.
From here on out, no more stealth. We are building in the open and as open source! More to come soon, in the meantime check out all the details in our blog.
Beep, boop. Come in, rebels. We’ve raised a 60m seed round to build the next developer platform. Open. Scalable. Independent. And we ship our first OSS release today.
entire.io/blog/hello-entire-…
Patrick Kerschbaum retweeted
Every team shipping AI-assisted code at scale needs new norms around quality gates, observability, and ownership.
Regardless of which model or toolchain you use, this is one of the most practical frameworks I've seen for adopting agentic development.
Software development is undergoing a renaissance in front of our eyes.
If you haven't used the tools recently, you likely are underestimating what you're missing. Since December, there's been a step function improvement in what tools like Codex can do. Some great engineers at OpenAI yesterday told me that their job has fundamentally changed since December. Prior to then, they could use Codex for unit tests; now it writes essentially all the code and does a great deal of their operations and debugging. Not everyone has yet made that leap, but it's usually because of factors besides the capability of the model.
Every company faces the same opportunity now, and navigating it well — just like with cloud computing or the Internet — requires careful thought. This post shares how OpenAI is currently approaching retooling our teams towards agentic software development. We're still learning and iterating, but here's how we're thinking about it right now:
As a first step, by March 31st, we're aiming that:
(1) For any technical task, the tool of first resort for humans is interacting with an agent rather than using an editor or terminal.
(2) The default way humans utilize agents is explicitly evaluated as safe, but also productive enough that most workflows do not need additional permissions.
In order to get there, here's what we recommended to the team a few weeks ago:
1. Take the time to try out the tools. The tools do sell themselves — many people have had amazing experiences with 5.2 in Codex, after having churned from codex web a few months ago. But many people are also so busy they haven't had a chance to try Codex yet or got stuck thinking "is there any way it could do X" rather than just trying.
- Designate an "agents captain" for your team — the primary person responsible for thinking about how agents can be brought into the teams' workflow.
- Share experiences or questions in a few designated internal channels
- Take a day for a company-wide Codex hackathon
2. Create skills and AGENTS[.md].
- Create and maintain an AGENTS[.md] for any project you work on; update the AGENTS[.md] whenever the agent does something wrong or struggles with a task.
- Write skills for anything that you get Codex to do, and commit it to the skills directory in a shared repository
3. Inventory and make accessible any internal tools.
- Maintain a list of tools that your team relies on, and make sure someone takes point on making it agent-accessible (such as via a CLI or MCP server).
4. Structure codebases to be agent-first. With the models changing so fast, this is still somewhat untrodden ground, and will require some exploration.
- Write tests which are quick to run, and create high-quality interfaces between components.
5. Say no to slop. Managing AI generated code at scale is an emerging problem, and will require new processes and conventions to keep code quality high
- Ensure that some human is accountable for any code that gets merged. As a code reviewer, maintain at least the same bar as you would for human-written code, and make sure the author understands what they're submitting.
6. Work on basic infra. There's a lot of room for everyone to build basic infrastructure, which can be guided by internal user feedback. The core tools are getting a lot better and more usable, but there's a lot of infrastructure that currently go around the tools, such as observability, tracking not just the committed code but the agent trajectories that led to them, and central management of the tools that agents are able to use.
Overall, adopting tools like Codex is not just a technical but also a deep cultural change, with a lot of downstream implications to figure out. We encourage every manager to drive this with their team, and to think through other action items — for example, per item 5 above, what else can prevent a lot of "functionally-correct but poorly-maintainable code" from creeping into codebases.
Patrick Kerschbaum retweeted
The future is software writing its own software. Which is why I'm so in love with Pi: a coding agent that can extend itself :) lucumr.pocoo.org/2026/1/31/p…
Patrick Kerschbaum retweeted
Every time we've made it easier to write software, we've ended up writing exponentially more of it.
When high-level languages replaced assembly, programmers didn't write less code - they wrote orders of magnitude more, tackling problems that would have been economically impossible before. When frameworks abstracted away the plumbing, we didn't reduce our output - we built more ambitious applications. When cloud platforms eliminated infrastructure management, we didn't scale back - we spun up services for use cases that never would have justified a server room.
@levie recently articulated why this pattern is about to repeat itself at a scale we haven't seen before, using Jevons Paradox as the frame. The argument resonates because it's playing out in real-time in our developer tools. The initial question everyone asks is "will this replace developers?" but just watch what actually happens. Teams that adopt these tools don't always shrink their engineering headcount - they expand their product surface area. The three-person startup that could only maintain one product now maintains four. The enterprise team that could only experiment with two approaches now tries seven.
The constraint being removed isn't competence but it's the activation energy required to start something new. Think about that internal tool you've been putting off because "it would take someone two weeks and we can't spare anyone"? Now it takes three hours. That refactoring you've been deferring because the risk/reward math didn't work? The math just changed.
This matters because software engineers are uniquely positioned to understand what's coming. We've seen this movie before, just in smaller domains. Every abstraction layer - from assembly to C to Python to frameworks to low-code - followed the same pattern. Each one was supposed to mean we'd need fewer developers. Each one instead enabled us to build more software.
Here's the part that deserves more attention imo: the barrier being lowered isn't just about writing code faster. It's about the types of problems that become economically viable to solve with software. Think about all the internal tools that don't exist at your company. Not because no one thought of them, but because the ROI calculation never cleared the bar. The custom dashboard that would make one team 10% more efficient but would take a week to build. The data pipeline that would unlock insights but requires specialized knowledge. The integration that would smooth a workflow but touches three different systems.
These aren't failing the cost-benefit analysis because the benefit is low - they're failing because the cost is high. Lower that cost by "10x", and suddenly you have an explosion of viable projects. This is exactly what's happening with AI-assisted development, and it's going to be more dramatic than previous transitions because we're making previously "impossible" work possible.
The second-order effects get really interesting when you consider that every new tool creates demand for more tools. When we made it easier to build web applications, we didn't just get more web applications - we got an entire ecosystem of monitoring tools, deployment platforms, debugging tools, and testing frameworks. Each of these spawned their own ecosystems. The compounding effect is nonlinear.
Now apply this logic to every domain where we're lowering the barrier to entry. Every new capability unlocked creates demand for supporting capabilities. Every workflow that becomes tractable creates demand for adjacent workflows. The surface area of what's economically viable expands in all directions.
For engineers specifically, this changes the calculus of what we choose to work on. Right now, we're trained to be incredibly selective about what we build because our time is the scarce resource. But when the cost of building drops dramatically, the limiting factor becomes imagination, "taste" and judgment, not implementation capacity. The skill shifts from "what can I build given my constraints?" to "what should we build given that constraints have in some ways been evaporated?"
The meta-point here is that we keep making the same prediction error. Every time we make something more efficient, we predict it will mean less of that thing. But efficiency improvements don't reduce demand - they reveal latent demand that was previously uneconomic to address. Coal. Computing. Cloud infrastructure. And now, knowledge work.
The pattern is so consistent that the burden of proof should shift. Instead of asking "will AI agents reduce the need for human knowledge workers?" we should be asking "what orders of magnitude increase in knowledge work output are we about to see?"
For software engineers it's the same transition we've navigated successfully several times already. The developers who thrived weren't the ones who resisted higher-level abstractions; they were the ones who used those abstractions to build more ambitious systems. The same logic applies now, just at a larger scale.
The real question is whether we're prepared for a world where the bottleneck shifts from "can we build this?" to "should we build this?" That's a fundamentally different problem space, and it requires fundamentally different skills.
We're about to find out what happens when the cost of knowledge work drops by an order of magnitude. History suggests we (perhaps) won't do less work - we'll discover we've been massively under-investing in knowledge work because it was too expensive to do all the things that were actually worth doing.
The paradox isn't that efficiency creates abundance. The paradox is that we keep being surprised by it.
Patrick Kerschbaum retweeted
All my new code will be closed-source from now on. I've contributed millions of lines of carefully written OSS code over the past decade, spent thousands of hours helping other people. If you want to use my libraries (1M+ downloads/month) in the future, you have to pay.
I made good money funneling people through my OSS and being recognized as expert in several fields. This was entirely based on HUMANS knowing and seeing me by USING and INTERACTING with my code. No humans will ever read my docs again when coding agents do it in seconds. Nobody will even know it's me who built it.
Look at Tailwind: 75 million downloads/month, more popular than ever, revenue down 80%, docs traffic down 40%, 75% of engineering team laid off. Someone submitted a PR to add LLM-optimized docs and Wathan had to decline - optimizing for agents accelerates his business's death. He's being asked to build the infrastructure for his own obsolescence.
Two of the most common OSS business models:
- Open Core: Give away the library, sell premium once you reach critical mass (Tailwind UI, Prisma Accelerate, Supabase Cloud...)
- Expertise Moat: Be THE expert in your library - consulting gigs, speaking, higher salary
Tailwind just proved the first one is dying. Agents bypass the documentation funnel. They don't see your premium tier. Every project relying on docs-to-premium conversion will face the same pressure: Prisma, Drizzle, MikroORM, Strapi, and many more.
The core insight: OSS monetization was always about attention. Human eyeballs on your docs, brand, expertise. That attention has literally moved into attention layers. Your docs trained the models that now make visiting you unnecessary. Human attention paid. Artificial attention doesn't.
Some OSS will keep going - wealthy devs doing it for fun or education. That's not a system, that's charity. Most popular OSS runs on economic incentives. Destroy them, they stop playing.
Why go closed-source? When the monetization funnel is broken, you move payment to the only point that still exists: access. OSS gave away access hoping to monetize attention downstream. Agents broke downstream. Closed-source gates access directly.
The final irony: OSS trained the models now killing it. We built our own replacement.
My prediction: a new marketplace emerges, built for agents. Want your agent to use Tailwind? Prisma? Pay per access. Libraries become APIs with meters. The old model: free code -> human attention -> monetization. The new model: pay at the gate or your agent doesn't get in.
Patrick Kerschbaum retweeted
Here's my favourite method for getting Go/Zig/Rust-like errors in TS.
It's by returning custom errors from functions.
- Shows right in the return type
- Easy checking with instanceof
- No deps required
Patrick Kerschbaum retweeted
There are over 30 different ways to handle React state.
Here's how I decide.
Patrick Kerschbaum retweeted
new blog post 👇 it breaks down a few approaches to configuring "live types" in TypeScript monorepos. you should never need to run `build` while developing!
1. tsconfig paths
2. custom export conditions
3. publishConfig (*my recommended solution)
colinhacks.com/essays/live-t…
Patrick Kerschbaum retweeted
Working on a new JavaScript package 📦? Here are some best practices on creating excellent documentation 👇
deno.com/blog/document-javas…
Patrick Kerschbaum retweeted
This is exactly why I won’t be touching Effect for a long time. Buying into a new language or even mental model is not just a personal decision. It’s a team/company/ecosystem one. Just like React and TypeScript, I will resist adoption until the network “effects” become so obviously positive that I feel universally obligated to do so.
Replying to @AdamRackis @EffectTS_
My current mental model, which the maintainers might disagree with, is this:
Effect should be treated like a new language, like Elm or ReScript, that happens to use TypeScript syntax.
This language has a ton of benefits. Strongly-typed errors. Built-in handling of complex things like concurrency, timeouts, data validation. Awesome composability with less FP bullshit.
Basically, you choose Effect as a new language to work in if you think that TypeScript is too loose. It makes your code more robust, and you ship fewer bugs.
Patrick Kerschbaum retweeted
“Duplicated code is often better than wrong abstraction.”
“Excessive copy/paste bloats the code, hurts consistency, slows reading, increases bug risks, and makes it harder to scale.”
Both are true.
So, avoid copy/paste. But also avoid premature abstractions.
It’s a balance.
Patrick Kerschbaum retweeted
Problem: React's useEffect only specifies when code should run. It doesn’t document why it should run or what it should do. This makes useEffect hard to read, debug, and maintain.
Solution: Use a custom ESLint rule to require using a named function.
Here’s a custom rule from @pkerschbaum
Here's the result:
!["no-restricted-syntax": [ "error", // Require naming the function passed to `useEffect`. { selector: ":matches(CallExpression[callee.object.name='React'][callee.property.name='useEffect'], CallExpression[callee.name='useEffect']) > :matches(ArrowFunctionExpression, FunctionExpression:not([id]))", message: "Functions passed to `useEffect` must be named to document intent. More info: https://x.com/housecor/status/1750980809874436431.", }, ],](https://pbs.twimg.com/media/GFap_ciXQAAnC1N.jpg?name=small&format=webp)
ALT "no-restricted-syntax": [ "error", // Require naming the function passed to `useEffect`. { selector: ":matches(CallExpression[callee.object.name='React'][callee.property.name='useEffect'], CallExpression[callee.name='useEffect']) > :matches(ArrowFunctionExpression, FunctionExpression:not([id]))", message: "Functions passed to `useEffect` must be named to document intent. More info: https://x.com/housecor/status/1750980809874436431.", }, ],






























