Overview of Automation at the speed of Swamp (Friends)
This episode is a wide-ranging conversation between Adam and Adam Jacob about how AI is reshaping software development, operations, and the structure of engineering teams. The centerpiece is Swamp, Jacob’s new project for reusable automation at the speed of agents. The core argument: software is now being built by software that helps build software, and the old ways of shipping, reviewing, and operating systems are quickly becoming obsolete.
What Swamp Is
Swamp is presented as a general-purpose automation system designed for the agentic era.
Core idea
- AI can now write and extend automation faster than humans can.
- Swamp gives the LLM an architecture for building reusable workflows, models, and extensions.
- It aims to make infrastructure and operational workflows as fast to produce as software itself.
What it can do
- Build workflows for:
- Proxmox VM management
- configuration management
- Wi-Fi troubleshooting
- cloud provisioning
- inventorying infrastructure
- deleting, cloning, creating, and managing systems
- Extend itself when integrations do not already exist
- Store and reuse data so future workflows can build on earlier ones
How the Workflow Works
Jacob describes Swamp as a system where the agent writes the automation, validates it, and then uses it.
The loop
- User describes an outcome.
- Swamp drafts a plan using software architecture language.
- Agents adversarially review the plan.
- The agent writes the implementation.
- Another agent reviews the pull request.
- Swamp runs UAT-style checks outside the agent’s control.
- If everything passes, the workflow ships.
Important details
- No human code review is required in the ideal path.
- The system uses UAT as a hard external gate.
- Agents can and do change tests, so validation has to live outside the agent’s control.
- The system is designed to be reusable, not just a one-off script generator.
The Big Thesis: AI Has Changed the Shape of Software
A major theme is that AI has created a new order of magnitude in software creation speed, and that changes everything downstream.
Key claims
- The bottleneck used to be “can we write the code?”
- That bottleneck is disappearing.
- Now the bottleneck is:
- architecture
- operations
- observability
- trust
- deployment
- collaboration
Implications
- Existing software stacks were built for a world where humans were the limiting factor.
- Many tools may collapse because they only existed to make systems easier for humans to manage.
- The stack will likely become simpler, more direct, and more agent-friendly.
Team Structure and Working Style
Jacob explains that his team shrank from 18 to 5 after Product-Market Fit failed, and that the small team is now working at a much higher speed.
How the team works
- Minimal blocking between teammates
- Morning synchronization, then autonomous execution
- Multiple agent-driven tasks running in parallel
- Heavy use of adversarial agents for planning and review
- Continuous correction instead of long handoffs
What changed
- Refactors that used to take months now take hours
- The team is more productive than when it was much larger
- The emotional experience of “a good day’s work” has changed for engineers
Why Software Architecture Matters More Than Ever
One of the strongest messages in the episode is that architecture is now central.
Old model
- Engineers often learned bottom-up:
- read code
- hack code
- refactor from the inside out
New model
- Agents can handle implementation quickly.
- Humans need to describe:
- system boundaries
- relationships
- desired outcomes
- architecture changes
- operational semantics
Recommendation
Jacob urges developers to learn:
- Domain-driven design
- architectural thinking
- how to express changes at the system level, not just the code level
Open Source, Contributions, and Trust
Swamp is open source, but Jacob is intentionally not accepting pull requests.
His reasoning
- Human review can’t keep up with agent-generated code volume.
- Supply-chain security is too risky if arbitrary code is submitted.
- The safer model is:
- users file issues
- the team implements them with agents
- co-authorship can be credited
Philosophy
- He believes the future may contain more free software, not less.
- The middle ground between human PRs and agentic code generation feels unsafe to him.
- Swamp is AGPL, reflecting his belief that open systems will matter even more in the agent era.
Where Jacob Thinks This Is Going
The conversation repeatedly returns to the idea that AI is not a small tooling improvement—it’s a structural change.
Likely outcomes
- More software, not less
- Better software, not just more of it
- New kinds of workflow automation
- Smaller teams doing work that used to require much larger ones
- Greater demand for people who can think in systems and architectures
Hard transition period
He is also blunt that the transition will be painful:
- layoffs will continue
- existing products and careers will be disrupted
- many engineers will resist the shift at first
- the industry is entering a period of uncomfortable recalibration
Practical Advice He Gives Engineers
Jacob’s marching orders for developers are straightforward:
- Start building with AI in the new way.
- Learn software architecture seriously.
- Stop assuming the old development loop is the future.
- Use more agents to solve problems.
- Build your own agentic workflows and software factories.
- Try tools like Swamp to understand the new shape of the work.
Notable Takeaways
- “The software writes itself.”
- “The bottleneck is no longer code; it’s architecture and operations.”
- “You have to be a good architect now.”
- “More agents is the answer to basically everything.”
- “The middle ground is death.” — his blunt way of saying the old hybrid approach won’t hold up long-term
Bottom Line
This episode is both a product demo and a manifesto. Jacob argues that AI has already changed software development at a fundamental level, and Swamp is his attempt to build the infrastructure layer for that new reality. The message is clear: the future belongs to engineers who can think in architectures, automate aggressively, and embrace agentic software creation.