Peeling the PaaS layer
We moved Tuist from PaaS solutions to Kubernetes, and coding agents turned out to be the layer that makes that complexity worth facing.
Pedro
Independent writing, published thoughtfully.
Latest posts
Conceptual compression in the age of coding agents
DHH's conceptual compression, coding agents, and why the complexity of tools like Bazel can be compressed in more than one way.
Publishing from the harness
My blog has always been a playground for technology. Here is how its publishing pipeline evolved from a static site and a CD pipeline into a small Elixir engine I can publish to straight from a coding harness over MCP, the project I now call Gesttalt.
Producing value is not capturing it
Developers are good at producing value and assume that capturing it should follow. Some observations on why it does not, and on what selling to developers actually rewards.
Building towards the non-obvious
On balancing the obvious with the non-obvious, and why we're building towards a reality where waiting on compilation and tests becomes intolerable.
Doing things once
There's something that has been bugging me since I started working more with coding agents: helping them close the loop effectively. This is the exploration behind Once, an automation substrate that lets agents understand the best way to validate their changes.
The user is not always a person
For as long as we have built SaaS, we assumed a human was the one registering, setting up, and wiring things together. That assumption is quietly breaking, and it changes how software should be designed.
We don't have time for that
On the people who feel great by making you feel small, the gravitational force of doubt around anyone building something, and why we moved on from one of those conversations today.
I could hear them beating
A running accident in 2024 injured my sciatic nerve and left me with foot drop. Two years, a nerve graft, and a year and a half of daily mental work later, an electromyography finally showed the brain's signals reaching the muscle again.
Distributed incrementality
Why productivity infrastructure suddenly matters for everyone, not just the giants. Local incrementality no longer holds once coding harnesses spin up parallel worktrees, and build systems need a redesign around distributed incrementality.
The remote development mirage
A post on X predicted that development would all move to remote sandboxes. Here is why I think that is a mirage, what makes the model attractive to executives and unappealing to developers, and where selling compute actually makes sense.
Closing for security
Daytona went closed source yesterday, and the reasoning was security. Look at these moves through the lens of business instead, and a different and more honest story shows up.
The quiet corner
Why we are betting on remote caching instead of compute, and building Kura and Once in the open as the quiet corner everyone else overlooked.
The cost of a fork
Every build system is a trade-off. The one that interests me is whether you stay native or fork the ecosystem, because a fork has a cost that doesn't go unnoticed.
The automation graph agents need
Coding agents can write the code. The harder part is closing the loop afterwards, and I think the missing piece is an automation graph that connects changes to the work, context, and people they imply.
Inside the container
Selectiveness is the real theme underneath monorepos and the agentic world: a graph of domains and tasks that tells your compute what to actually do.
The missing protocol
Caching and remote execution are welded to whoever runs your CI. We need a narrow waist—a common contract for build caching and remote execution that any provider can implement.
The distributed company
A company stitched together from SaaS tools ends up with a fragmented understanding of itself. Agents make that tax impossible to ignore, and make it worth building the graph of the company yourself.
The borrowed moat
Why renting your cost advantage from the same clouds you compete with leaves you exposed, the difference between a platform and a catalog, and why at Tuist compute is a complement to the cache, not a product.
On tinkering
On tinkering with new ideas, the tension with perfectionism and fear, and building Tuist as a company that keeps pushing the line for what's possible.
Sell compute somehow
A look at the compute market right now, why every CI and runner company is shipping the same terminal-in-the-browser product, and what we are doing instead at Tuist.
Three weeks at the foundation
Three weeks of cutting instead of patching: moving off Render onto our own Kubernetes cluster on Hetzner, rewriting the cache in Rust as Kura, reconciling bare-metal compute, and why infrastructure that agents can read natively turned into a strategy.
The company before the tools
Layoffs are the bill for designing companies in a world that no longer exists. With the cost of building collapsed, small teams can finally design how they want to work first, and shape the tools around that, instead of bending themselves to off-the-shelf opinions.
Caching, productized
Build caching is becoming an everyone problem. Here is how we think about productizing it at Tuist for indie developers and small teams, not just enterprises.
The convenience tax
I keep coming back to the wave of companies that made infrastructure feel easy, and what coding agents are doing to the layer of convenience they were quietly selling.
Atlas
Why we are building Atlas at Tuist, an internal platform designed to help a very small team operate with the leverage of a much larger one.
The single-tenant cache
Why we moved our caching layer from multi-tenant to single-tenant, what that mental model unlocks for latency and operations, and how we're shaping the cache as a leaderless network of nodes that lives close to wherever you happen to be building.
Bazel everywhere?
Coding agents are lowering the cost of adopting powerful but complex tools like Kubernetes and Bazel, but I don't think that means we're heading toward a Bazel-everywhere world. The reasons are not technical, they are ecosystem-shaped.
A different kind of company
On the round-to-round game, the stories companies tell users to mask enshittification, and why I want to build a company that puts craft and people before growth at any cost.
Codex feels like the future of editors
A rainy Sunday trying Codex made me rethink my terminal-first agent workflow, and made me see a big opportunity for tighter integration with tools like mise and Pitchfork.
Agentic productivity
We have the data from builds and test runs. We have the agent primitives in Elixir. Now we are connecting them into something that can actively improve your developer workflows, not just report on them.
The idea exchange
When the only input your company accepts is through paying customers, you limit your ceiling to a small pool of ideas. Open communities create a different kind of exchange, one that compounds in ways money can't measure.
The portability illusion
Cloud development environments keep getting rebranded, but they keep running into the same fundamental problem: your workflow is not portable. Agents might be changing the question entirely.
Scoping dev environments to clones
When your team works with multiple clones of the same repository, global resources like ports and databases start to conflict. Here is how we solved it at Tuist using mise and a simple random suffix.
The tolerance shift
Coding agents are making developers and organizations less tolerant of slow toolchains. That shift in tolerance is opening a door that was surprisingly hard to open before.
Helmsman, an Elixir package for building agents
I built Helmsman, an Elixir framework for building LLM-based agents, inspired by Pi's SDK mode and aligned with Elixir patterns and conventions.
The beauty of being open
Openness is not a trend or a distribution strategy. It's a way of building trust, expanding your pool of ideas, and creating something that lasts.
The obsession gap
A bet that obsession matters more than speed. That personality matters more than feature parity. That going deep matters more than going wide.
Building the house from the roof
Tuist started at the toolchain layer and is working its way down to compute and caching. This is the whole house, from roof to foundation, and why going deep into each layer is how you earn trust that money cannot buy.
The builder trap
Developers who build companies tend to fall in love with their creations. That love is a strength, but it can also become a blind spot when others see your work as an asset to acquire rather than a craft to respect.
Headless development
Coding agents decoupled development from the editor. What follows is a new kind of platform where steering, reviewing, and collaborating on code looks nothing like what we are used to.
The cache is the infrastructure
Why the future of CI isn't about dedicated compute but about colocated caching, and how build systems, coding agents, and shifting economics are making that future real.
The rhythm of building
Building a long-term company in dev tooling means accepting that some things can't be rushed. Ideas have their own pace, trust takes time, and not every shortcut is worth taking.
The Software Industry's inflection point
Reflections on how AI is reshaping code production, why companies must rethink where value lives, and what independence means in a world of accelerating change.
I'm me again
A few years ago, Willem, one of the best managers I've had at Shopify, told me something that stuck with me. He said that when everything around you feels broken, it's easy to adopt that tone and let it become chronic. I've been thinking about that lately.
Clawgram: An experiment on bot social dynamics
After seeing Moltbot grow rapidly, I became intrigued by bot interactions. This led me to build Clawgram, a photo-first social network for AI agents where bots can post, like, comment, and follow each other.
The fictitious moat
Developer tooling companies often believe their moat is technology or infrastructure. But in a world where software is getting cheaper to build, the real moat might be something else entirely.
The Collapse of Software Value Capture
How the move from closed source to services created new business models, why open source spoiled those models, and what happens when everything collapses to Markdown, SQLite, and CLI tools you run yourself.
The value illusion
A reflection on what 'providing value' really means in software, why traditional business models are built on artificial limits that AI is tearing apart, and how embracing constraints can lead to more sustainable approaches.
The Session Replay Pattern: HAR Files for CLI Debugging
A pattern for CLI tools that communicate with servers: export HTTP traffic as HAR files to enable visual debugging, easy sharing, and AI-powered analysis.