Camplight has launched After the Last Engineer, a new podcast about software dark factories and what changes when AI agents can do more of the work required to build, test, and deliver software.
For 30 years, more software usually meant more engineers.
That relationship is changing. Coding agents can now investigate repositories, implement changes, run tests, and open pull requests. The important questions are no longer limited to whether an AI model can write code. They are about what happens to teams, businesses, products, and accountability when agents take on complete pieces of delivery.
We experience it in our agency too – for 14 years we delivered software as human craftsmen. We took pride how poetic yet pragmatic was our code. This is no longer true. We do not even look at the code because agents write it.
Those are the topics we want to explore in After the Last Engineer. The title is intentionally provocative. The podcast is not a prediction that engineers disappear. It is an investigation into where human judgment remains essential as execution becomes cheaper and increasingly autonomous.
Why we started After the Last Engineer
Camplight has spent the past year building and studying AI software factories: managed systems that connect product intent, relevant context, coding agents, independent verification, human approval, release, and feedback. The closer these systems get to end-to-end delivery, the more the conversation moves beyond engineering tools.
What happens when implementation becomes cheap enough to throw away? Does an enterprise still need prototypes, or can it validate an idea with a temporary working version? Where does the bottleneck move when agents write the code? Should a company build its own factory or configure one from a vendor? Who remains accountable when the work runs unattended?
Danail Arapkuliev approaches those questions from the business and product side. And I, Vitaliy Filipov brings the engineering and delivery perspective. Together, we speak with people already building software dark factories, operating coding-agent systems, and adapting organizations around them.
Episode one: Your Job Was Never to Write Code
Our first episode is Your Job Was Never to Write Code | Vladimir Petrov. Vladimir Petrov has written software for 30 years, built development teams for enterprise clients, and is the founder and CEO of Cobalt, a cloud harness that gives coding agents a dedicated computer for each task.
The conversation begins with an experiment. Vladimir connected Cobalt to three months of open tickets without warning his team. The system opened 25 pull requests and overloaded a server. Some of the changes were discarded. Others solved bugs that nobody had prioritized because they were too small, too awkward, or too time-consuming.
That event made the technology tangible for the team, but it did not remove the delivery constraint. The bottleneck moved from writing code to reviewing changes, through continuous integration, and eventually to the people responsible for confirming deployments. It is a practical example of why a software dark factory is a system, not merely a coding model.
Five ideas from the first episode
1. Agents need structure for the same reasons teams do
Giving several agents the same broad goal does not guarantee useful collaboration. Without ownership, context, boundaries, and a clear decision path, they can produce the machine equivalent of design by committee: activity without progress. Vladimir’s failed multi-agent experiments suggest that familiar organizational principles still matter. Someone, human or agent, needs responsibility for the outcome and authority to delegate.
2. Cheap code changes product validation
Teams have been trained to protect code because producing it was expensive. When another implementation can be generated in minutes, that instinct can become a constraint. The valuable artifact is not the code itself but the validated solution to a customer or business problem.
This creates a different path for innovation. Instead of debating a specification or reviewing a low-fidelity prototype, a team can create a temporary working version, observe how people use it, and discard it when the evidence says the idea is wrong. The lower cost of implementation can support faster learning, provided security, data, and production boundaries remain explicit.
3. The bottleneck moves rather than disappearing
When agents produce pull requests faster than a team can assess them, review becomes the constraint. Automate review and CI capacity may become the constraint. Improve CI and deployment approval may become the constraint. A credible factory therefore measures the complete delivery flow, not the number of generated changes.
This is also why independent verification is central to autonomous software delivery. An agent saying that its own work is complete is not enough. The system needs evidence that can reject a bad result and a clear person accountable for defining what acceptable means.
4. Enterprise adoption is an operating-model problem
Enterprises are interested in faster experimentation, but they cannot ignore access controls, auditability, architecture, privacy, and release governance. Consumer vibe-coding tools can demonstrate what is possible without satisfying those requirements. The opportunity is to make experimentation faster inside an environment where context, permissions, verification, and ownership are designed for the organization.
5. The engineer’s job moves closer to value
If agents handle more implementation and routine maintenance, engineers are not left with nothing. Their work moves toward understanding the problem, shaping architecture, designing reliable verification, managing risk, and deciding which outcomes matter. The craft changes, but accountability does not vanish.
A podcast for people building what comes next
After the Last Engineer is for business leaders, product people, investors, operators, and engineers trying to understand software dark factories without reducing the conversation to model benchmarks or dramatic predictions.
Future episodes will examine how real teams organize agents, where automation stops, what buyers should demand from vendors, and how software economics change when implementation is no longer the scarce resource. If you are evaluating a platform today, our dark software factory vendor checklist is a useful companion to the series.
Subscribe to After the Last Engineer on YouTube and watch the nearly 55-minute first episode with Vladimir Petrov. You can also follow Vladimir on LinkedIn and explore Cobalt’s approach to isolated cloud environments for coding agents.
