Words are just words. In tech especially, it seems anyone can call themselves whatever they want.
Someone who chooses to call themselves "programmer" can be more engineering-minded and see the big picture better than someone that calls themselves an engineer.
I also started out in systems programming and we still call ourselves programmers there, when there is a lot of systems "engineering" (aka trying not to blow up the system with your code running in supervisor state) going on.
So I'll keep to calling myself programmer amongst my non software engineering friends. It just seems more humble.
That being said, writing the code has like others have pointed out, never been the largest part of the job in my experience.
Who's laughing now? Who still has a job now?
As of September, this is objectively false. When "programming in the small", frontier LLMs write better code than 80%-90% of human devs and are much more thorough about checking their work than most human devs. They are also starting to exhibit signs of good judgement in design and architecture, not just implementation, which is why you need a software architect in order to steer things, but hands-on-keyboard programmers? Yeah, you need far fewer of those now.
When "programming in the large", yeah, they're not there yet. But that's coming.
I think both definitions are still too narrow for what I do daily. I fully agree that we still need humans to decide what to build, how it should all fit together, etc.
But both definitions do not really take into account the huge social dimension of being a good (computer) engineer in a company. You have to translate requests from a wild variety of users into what this means for a system. You have to recognize and explain that what they need is not always what they think they need. You have to be able to say "no" to things. All these things are very hard for an LLM (reading humans, not literally following requests).
Then there are social aspects like building consensus within a project, building a user base of many people that are initially skeptical, using existing relations with people and other companies to slowly adopt what you are building, etc.
Programming used to be a large chunk of the work. I thoroughly enjoyed this aspect of the work when I was younger, but at some point I started enjoying system design and everything around it more. So in that sense, programming with LLMs is much nicer (though I still review every single line of code and often have to go through a couple of iterations because even Opus 5.5 often doesn't get it 'right' in the first take). But the remaining part of the work is extremely hard for an LLM to replace.
How do you justify saying "no" when there is a magic machine invented 3 years ago that'll do it? Your gut says it's a maintenance nightmare, your LLM says it's already done implementing it.
I regularly meet (recently examined) people who are trained "software architects". Common among them is that they are often delay projects championing their pet idea, sometimes bringing negative value to the project. The best programmers are just so much better software architects also. So I expect history to repeat at this point.
You don't forget CS concepts so easily, but all the syntactic tricks of new language variants and working set vocabulary of APIs, data formats, and frameworks keeps churning away from whatever you last had contacted in a real, hands-on way.
It is fascinating, wondering where this is going as programmers turn into their own middle managers on top of agents. Particularly, the school who claim that you don't really need to understand all the code and instead treat it like a black-box experiment. If this fad takes over the main stage, then everyone becomes one of those less technical managers.
But, in this new scenario, there is no human in the loop to inject judgement calls and "manage up" anymore. There is no programmer culture except the models and agents, which don't really have the same social connections to drive a programming culture. What will happen? A culture per agent product? Per enterprise client of the agent vendor? Per agent operator? Per codebase?
About half a year ago I noticed there were no people called 'Agile something' at our org, so I asked about it. They looked at me like I was a space alien. I remember, it was like 3 years ago that management bet the house on 'Agile transformation' talking about how Agile practices are the bread and butter of a good organization.
Now they're talking about AI the same way.
The memo has NOT gotten around, though AI now makes it easier to make all the various slide decks and schedule all the 50+ person meetings that power this process.
Negative value to the project, perhaps; but if these "software architects" are kept around despite several rounds of this, it may be because they're providing positive value to the company, in terms of:
- being able to provide the executive team corroborating evidence to show to investors to convince them that they're acting strategically in the market; or
- where the existence of the project, no matter how failed, serves as collateral to get breathless puff-piece articles written about the company in places where dumb CTOs/CIOs who make IT buying decisions will read them (and not necessarily buy the product that came out of that project — hopefully not! — but remember the company itself the next time they're comparing vendors for something else.)
This is a holdout from the time when the whole software development field was still stuck with the idea that waterfall/big design up front was an adequate way of doing things.
The belief was that, like any engineering field, systems would first be designed in detail before anyone could even open an IDE.
This approach was quickly proven to be wrong, expensive, and fruitless. Agile started to emerge as an effective approach to the problem of developing and maintaining software systems. The uselessness of the system analyst role, when contrasted with the fact that mere programmers could easily implement features without guidance from an enlightened individual far removed from the problem domain, was readily noted.
Milt realized as early as the 1970s, if not long before, that programmers had way too much power in an organization because most organizations adopted a "tool-oriented approach" to computer technology: here's a tool, how do we make use of it? They let the programmers run wild, and the result was software that was a buggy mess. What's needed is a management-oriented approach in which the management of the company calls the shots on what's needed for the company to function.
In PRIDE, the systems analyst is centered. This is explicitly a business role, not a technical role, and their job is to understand the business in such a way that the information systems (not programs, nor apps) that drive the business can be described in diagrams and text. Only once the requirements, definitions of terms, and data definitions have been established and standardized can the implementation phase begin. Bryce estimated that if you're not spending 65% of the effort in systems analysis and only 15% of the effort in programming, you're doing it wrong.
This is how grown-ups did information systems for decades. And then the internet happened, "hacker culture" happened, and the programmers were back in the driver's seat, producing things like "Agile".
Now we have AI, and to quote another commenter elsewhere in the thread, the programmers have had their tails cut off. That 15% number asymptotically approaches zero. But the systems analysis still needs to be done, and for the foreseeable future anyway, that needs a human touch.
Become a business person, not a "software engineer". They are the ones who will drive things forward in the agentic era.
A counter to this is "requirements change quickly, therefore the system needs to change quickly too." But the actual case is: most organizations don't really know how to do systems analysis. So this results in one of two scenarios: either the organization wastes a lot of time and money in the analysis phase struggling to do what they cannot, or they punt on requirements analysis altogether and wait for requirements to surface at implementation time. This is called "Agile" today, but was described by Milt in 1983: "do a superficial feasibility study, do some quick and dirty systems design, spend a lot of time in programming, install prematurely so you can irritate the users sooner, and then keep working on it till you get something accomplished."
PRIDE is like a textbook on how to build a system, from requirements analysis through design, implementation, and maintenance. It was the first methodology for doing so, and it transformed information systems from arcane art into a proven, repeatable science. It should be the industry standard, but is now at risk of being forgotten, largely due to programmers holding the industry hostage.
AI is taking programmers out of the equation. PRIDE is relevant again.
Maybe that will change with LLMs, but you’ve got the causality arrow backwards. Systems analysts didn’t disappear because of Agile; Agile exists because that way of working didn’t work.
Source: I was on the front lines of the first Agile wave starting in late 1999.
(And then what people actually adopted as “Agile” generally wasn’t what was created by the first wave of the Agile community, but that’s a whole ‘nother topic.)
But there's a more general kind of "systems analyst" that still survives (and is mostly what the BLS stats refer to): a person whose job is to map out the current business domain of a system (consisting of not just computers, but also people, infrastructure, institutions, etc.) and identify where it will need to be modified (but not necessarily how it will need to be modified) to make it capable of being put to use in a certain way for a given plan/mission.
Systems analysts in this sense tend to be one of the actual workhorse jobs inside "management consulting" firms and "think tanks." Governments, militaries, and large bureaucracies with many independent business units (think IBM) are their customers.
Systems analysis is sometimes done structurally over an entire organization: someone at a very high level has some new vision for an initiative, and hires these companies/think-tanks to help them determine how to "align" their organizational architecture with what a military might call a new "doctrine" or a company might call a new "paradigm." In these cases, the systems analyst performs the first step of that alignment: understanding "the system as it is today", and identifying what parts of it are already aligned vs. which parts will need to change. Their output is a report to the person driving the process.
But structural analysis is more often applied to specific strategic/business units, as the result of that strategic/business unit being chosen to execute a given strategic mission, as an enablement process to get that unit into the specific shape it needs to be in to execute that mission. In this case, there is likely an assigned "mission {planner, architect}" (who may also become the mission's director; or who may hire for such a director role and then depart to go plan the next mission.) The systems analyst works for/with the mission planner as their "eyes and ears", interacting with the business unit to gather information for the planner to use.
In both the structural and strategic cases, there are usually also one or more systems engineers who determine the "how" for implementation of these changes. (A mission planner is usually a very senior systems engineer themselves.)
However, unlike the systems analyst, who is considered more trustworthy to central leadership when they exist outside of the system they're analyzing (and so mostly work for external firms like think-tanks rather than for the orgs themselves), there's much less of a motivation to separate out systems engineering in that manner. So systems engineers (including mission planners!) tend to be regular [if high-paid] career employees of the central organization. These folks are frequently "general staff" in a military (with no real analogous term, AFAIK, for the equivalent people within a conglomerate's parent company.)
Due to their value coming in part from existing in separate firms that can negotiate on their behalf, systems analysts in this sense are well-paid indeed! But also worked hard, bounced around, and signing NDAs constantly. And possibly a bit bitter, in that they often see how things are broken with no chance to be part of the fix.
This is not legal advice but allegedly lawyers were instructing CSA category TN applicants to never ever mention that they are “coding” or “programming”
The systems analyst analyzed the problem that needed to be solved and designed a solution involving a computer, including system modules, inputs, outputs, etc.
The programmer, supposedly a lower paid profession, transformed that into Computer code. I remember someone telling me that wasn't the best choice.
I think this distinction still survives in government labor statistics.