People keep asking what happens to software engineers if AI gets good enough to build most software.
Some think the role disappears. Once the machines can do the work, why keep the workers?
But that assumes the work itself disappears. Usually it doesn't. Usually the work changes shape.
Software has long been treated like a kind of manufacturing. The industry borrowed Kanban from manufacturing for a reason. We talk about pipelines, throughput, bottlenecks, quality assurance, backlogs, release cycles, handoffs, defects, production incidents. None of this language is accidental. Software companies already looked like factories. They just had unusually skilled line workers.
That was the strange thing about software.
In most factories, engineers don't stand on the line assembling each unit. They design processes, improve systems, manage constraints, troubleshoot failures, and raise output quality. The line itself is run by the production system.
Software was different. The engineers were often both the engineers and the line workers. They understood the system, but they were also the ones physically producing the thing.
That may have been a temporary condition.
If AI keeps improving, then the actual line work of software production increasingly gets done by machines. Not all at once, and not perfectly, but clearly enough that the direction matters more than the present imperfections. The old line workers are no longer needed in the same way.
So the real question is not whether software is becoming manufacturing. It already was.
The real question is what happens when the manufacturing line gets automated.
One possibility is that software engineers disappear, because the machines replace them.
Another is that they evolve into something closer to what engineers in manufacturing have often been: the people who run the factory.
That doesn't mean their job becomes less technical. Probably the opposite. Running a factory is harder than standing on a line. You need to understand the machinery, the process, the tradeoffs, the quality standards, the failure modes, and the economics of the whole system. You are responsible not for one unit, but for whether the system reliably produces good units at scale.
That sounds much closer to where software engineering may be headed.
The software engineer of the future may spend less time directly producing software and more time designing the environment that produces it. Choosing tools. Structuring workflows. Setting constraints. Deciding how work gets broken down. Building the systems around the systems. Managing the factory, not staffing the line.
This also helps explain why so many people are confused about entry-level roles.
The old career path made sense in a world where humans were the production layer. You started with simpler tasks, learned by doing, and gradually moved toward harder and more abstract work. But if the simpler production tasks are the first to be automated, then that ladder breaks. The bottom rungs were attached to the line.
That doesn't mean there is no ladder. It means the ladder probably looks different.
In manufacturing, people do not usually become capable of running a plant by spending twenty years manually assembling one product. They learn by understanding operations, constraints, exceptions, quality control, throughput, and system behavior. They learn how the factory works.
Something similar may happen in software.
The new junior engineer may not be a weaker version of the old senior engineer. They may be someone learning how software factories behave: where automation fails, where outputs drift, where systems need tighter constraints, where production slows down, where quality breaks, where the process itself needs redesign.
That would still be engineering. Just not line work.
It would also explain why software engineers may remain essential even if more people across a company can create software. Product managers will make more software. Designers will make more software. Operators will make more software. Customer-facing teams will make more software. Once the production layer is automated, many more people can interact with it.
But that doesn't remove the need for engineers. It changes what engineers are for.
Someone still has to understand the factory well enough to make it work.
And that, oddly enough, sounds more like engineering in the traditional sense than software engineering did during the period when engineers were stuck doing line work.
For a long time, software was a factory whose line workers happened to be highly trained engineers.
AI may end that arrangement.
Not by eliminating software engineering, but by finally separating the line from the people who run it.