Something that I’ve noticed at my company and other companies friends work at is an increasing number of software engineers who do not write code at all. They just write documents, comment on documents, go to meetings, and ask questions in emails. Lots of these types where I work and where my friends work (very well known companies). I do not think this is healthy for a company to have its mid and senior devs writing no code in the numbers I’m seeing.
That sounds like good old Waterfall to me. Or in its current form SAFE. 90% communication 10% code. And something like that is basically what it takes when you have hundreds or thousands of people working on the same product.
Making sure that everyone understands how to use your part (and that the overall architecture is at least coherent), in a big project, is actually more important than if that part is of high quality. And since communication is more important it's the seniors responsibility.
Sometimes I really want to go back to the junior years it was in general more fun back then. But getting to decide the architecture does have its charms.
yup, 100% true. If you have not worked in such a big company (say more than 500 people), you can't imagine how much politics/communication/organisation/standards/procedures are important both in term of, well, importance, and time you spend on it. In the company I worked, you had about 1 analyst for 2 devs and 1 PM for 10 persons. So more than one third of the team was never writing code. Add in the time spent in meetings, talks, testing, understanding and yeah, I'm sure about 50% of the time was spent not coding.
It's a consequence of scale. Beyond a critical mass of complexity, it becomes more work to envision the moving parts and orchestrate changes among them, than writing the code itself.
Personally, I think most software systems could accept fewer moving parts if we allowed certain tradeoffs, and the benefit would be much more empowered engineers.
Seems like you put too much value on writing code.
As a senior dev preventing business from bad decisions and preventing code that should never be written is more valuable.
Code is liability.
To propose solutions I still need to know the code for the system so it is not like suddenly I lost ability to write or understand code. But coding - is only one of many tools for creating a system.
> As a senior dev preventing business from bad decisions and preventing code that should never be written is more valuable.
Except, this could be done better and cheaper by a literal rock with letters spelling "NO" written on it with a sharpie.
If a software company doesn't write any code, what exactly is it doing? And speaking of bad decisions, surely some have been made already, since everyone is doing the job they're the least qualified for.
> If a software company doesn't write any code, what exactly is it doing
Not all companies are “software companies” and it still takes level of maturity to know when to write code and when to outsource.
At the interview for my n-2 job, I was interviewing with the director of IT and a junior to mid level dev.
The mid level dev asked me how I would write an address validation module.
My answer was that I wouldn’t and went into details all of the complications of validating addresses and that I would use 3rd party CASS software. I went on to explain that from what I know about the core business it wouldn’t be a competitive advantage and that “it wouldn’t make the beer taste better”.
The software dev wasn’t impressed, the director was.
I was hired as a senior dev and I was ruthless about using third party software from reputable companies instead of writing code internally. This company has no desire to hire a bunch of devs.
We had specialized consultants for Salesforce, Workday, our data capture system, learning management systems, AWS and everything else.
In about a year and a half, I put myself out of a job, they went public and are running smoothly seven years later from what I can tell talking to former coworkers.
But I sure did have a great story to tell interviewing for my current position working in the consulting department at BigTech.
There's not much more I can add, but there's something I must pick on, in the name of countless users who suffer because of this:
> My answer was that I wouldn’t and went into details all of the complications of validating addresses
So far, so good...
> and that I would use 3rd party CASS software.
Why? The correct answer almost universally is: "I would not do that thing, period, because it's a lose-lose idea that hurts both you and your customers". Same with validating people's names.
EDIT: Since downthread you mention it was a system "for a health care company that sent at home nurses to special needs kids", part of which involved said nurses doing data entry... I wonder how much those nurses loved the address validation "feature" and how many serious issues (as in, with actual consequences to someone's health) it caused.
> Why? The correct answer almost universally is: "I would not do that thing, period, because it's a lose-lose idea that hurts both you and your customers". Same with validating people's names.
For a lot of industries, bulk address verification is a requirement to get a cheaper mailing rate. I first started using it when I was working for a SaaS company that printed and mailed bills and statements to customers.
It made no sense for a health care company that sent at home nurses to special needs kids to write their own in house EMS/EHS system. And they had an in house one that they had been depending on in 2015. It was built using PowerBuilder from 1999 and running SQL Server 2000. They were “locked into” supporting an old PowerBuilder app.
It also wouldn’t have made sense to hire a bunch of mobile developers to write a data capture system written for Android devices for their nurses. I had been there done that eight years prior when I did work for a company that wrote field service software for ruggedized Windows CE devices and 5 years prior when I did something similar for rail car repairmen.
It also wouldn’t make sense for them to write anything that could be done with Salesforce or a third party LMS.
Software developers are a cost center to a non software company.
Your company is one consultant away from deciding that your role, as you dont write much code, could be better done by someone who is a full time manager who has an MBA fresh out of university and no coding skills.
I've actually seen these kinds of very-valuable positions replace by the mythical "TPM", who (unless they are very good) has zero hands-on knowledge and wants none. They are worse than unhelpful. A good prin engineer gives all the same schedule updates and cross-functional requirements-wrangling that a mediocre TPM would, but also produces useful code examples, coaching, and PR reviews.
It's the culture of over-communication. In the last 8 year or so, I have noticed my ability to actually write code had dropped through the floor. Everything has to be discussed to death, reviewed, approved, and go through a release process and red tape that would make the US State Department blush. And the end result is still slow and inefficient. There is just no time to make it better as you move on to discuss something else to death, while drowning in a sea of Slack messages.
At one level I understand it. Gone are the days of us hacking away as an island, playing around, experimenting. Software engineering is more mature, boring, and corporate.
As my career progresses I find myself reviewing code, mentoring, deciding on architecture and running around helping way more people. I still do hands on coding but my workday had completely changed since when I first started out.
As long as they're also reviewing code, I think this is fine. They're scaling their knowledge and impact. Obviously there has to be a healthy ratio of senior:non-senior for this to work as well (maybe 1:4-5?).
I literally had a "senior cloud architect" tell me that he didn't understand how one of his team's apps works because "he only draws the boxes" and then laughed it off.
I think there can some some truth to that. As I progressed into more architectural work, you have to leave the deep technical details behind, and you do miss it. But you can't do everything.
Eh, careful what you wish for. There's two extremes, and I've had the displeasure of seeing them both.
The first is those who write only code, with no regards for the overall design or documentation of the system, and are completely unable to formulate answers about the high-level functioning of the system, often ask for things based on a low-level need with no regard for what could or should happen at a high level, because nobody has the high level picture.
The other one is armchair architects who will draw system diagrams utterly disconnected from reality, with sub-systems doing things they cannot do, that we will never hire the engineering to do, etc. They'll mandate "common APIs" and "everything must be REST" (but where REST is their personal vision, which is inevitable not RESTful at all, and often is just a bespoke RPC/HTTP style API).
There's a happy medium in the middle: engineers who understand the code, can be productive in the code, but also understand and are making conscious decisions about what the highlevel should be, making design docs, emailing about intentions, etc.
Management has to offer the environment for that to flourish though: there has to be the time for documentation, the time for the design to emerge and for bugs to be worked out. But if everything is just a PM's pet ticket that is due "yesterday" and it must be done because management decrees it and once it is, repeat? Then that'll never happen, and those eng will quickly find greener pastures.
Sometimes it's really petty stuff, too. I've lost the fight of "engineering needs a mailing list to discuss technical changes, TDDs they'd like a review on, etc. There needs to be an alias for engineers to do engineering" — and yeah, no TDDs have happened since!
Yeah so just wanted to chime in here. I 100% agree. I have worked at both extremes.
My current gig is basically the first one. Nobody has the big picture. Nobody wants to discuss the big picture. They are only interested in checking off the boxes associated with the task they currently have assigned. Everything is due yesterday because there is no actual priority list and our priorities shift on a daily basis. It's utter chaos.
We are writing an ERP system. It is slowly shaping up to be a complete disaster. I have spent the last eight months trying to change this approach and attempting to lead by example.
It's not working. I will be moving on soon.
TLDR: Just because somebody can afford to hire a software engineer, doesn't mean they should hire a software engineer.
Sounds like a Business Analyst and perhaps Technical Writer. Not something the developer should usually spend most of their time doing, but a bit is good.
Someone reading the code should also be capable of understanding the problem that it solves and documenting the use of the code. If your code is fairly well written, I mean.
Code, like say English poetry, can be subtle. Reading the code can easily answer the question "what does this do?", but it usually doesn't answer "why are we doing it?"
Most importantly it doesn't tell us what we're not doing here, and why not.
I find myself adding comments to my own code when 6 months after the fact I'm re-discovering why something that looks casual is really important. Why that one "obvious " improvement or optimization is -not- done.
But that's documentation at the lowest level. Most of my documentation time (and I'll admit to writing a lot of docs) is about a bigger picture; hoe is the code used, what problems does it solve, how it interacts with the world and so on.
Documentation is not about writing the obvious "this increments x", its about making the code reusable, making it useful to yourself and your colleagues, my noting that it exists.
It I'd if you like the "search index" into the code.
I think you misread the GP. These "mid and senior devs" are writing documents not documentation. They're not writing comments or wiki pages, they're writing designs docs for new systems, proposals for cross-cutting initiatives, etc. They're taking their knowledge of the domain, its issues, and general wisdom and applying it at a scale larger than a single developer's output.
In theory, this makes perfect sense and is a great way to amplify a more senior developer's impact compared to just coding "the hard stuff." In practice, unfortunately, this leads to a "doc culture" where there's often too much focus on the writing & documents and not enough on the coding & getting shit done.
For example, look at Amazon. Writing is considered a core SDE skill, yet atrocious code (especially from more senior "lifers") and shitty half-solutions are seemingly desirable. Promotion at Amazon is about telling a story of your impact in your promo doc, not about explaining to the powers that be that you're a kick-ass engineer who needs harder problems.
I have seen this more and more as well. In my experience, it tends to be developers who are aiming to switch to project management at some point in their careers.
it's frustrating because capacity planning expects that all engineers / ICs write code at least 75% of their time. the effect is that titles+headcount no longer accurately reflects what are and arent reasonable deliverables / deadlines for a team.
I dunno, it depends entirely on the industry etc; code is, after all, but the final product, the implementation detail of your company. So many (too many?) developers focus too much on code, on output in lines of code, instead of building the right thing.
This is why in a lot of companies, internal tools (like issue trackers, performance monitoring, logging, orchestration, testing, etc) are written and rewritten over and over again. The idea that building your own is better than using off the shelf software. But it's self-gratification, it's avoiding the company's own / real problems and products.
Writing code without a plan or purpose is wasteful.
To be fair, unless you're building some low level infrastructural systems, coding is the easiest part, and code is cheap.
Drop any senior dev into coding duty, and their skills return after one to two weeks. On the other hand, asking a junior dev to implement a new system that integrates with 3 other departments, and you'll have to wait two quarters for them just to figure out who to talk to and how to get consensus.
If an enterprise has well defined interfaces for teams to interact with one another and effective escalation points for conflicts in priorities then communication might be the cheap & easy part.
Conversely, small modifications to a messy codebase can be extremely time consuming. Imagine being asked to fix an animation bug on an in house date picker in a large Angular app that hadn't been updated in 5 years.
There's a misunderstanding here due to context. Someone working in a startup (been there) will find it difficult to understand just now much communications are required to get anything done in a large MNC. Out of necessity, people who have pushed enough code to understand the systems have to step up to do the comms instead of being siloed. I had many a time freaked out some other team because the phrasing of my email made them think we're going to dump more work on them. This is the actual difficult part about engineering at scale: Getting everyone on the right page.
You can opt to keep coding, but it won't get you far in your career. Does this mean the communications have more value than actual implementation? It depends. Again, this value differs at different company sizes.
I just got the chance to code again last month, and I've already completed 5 features (code reviewed) that the juniors couldn't complete in a year. I won't say they are worse at coding, but more that I am more familiar with how dependencies work because I've already done the same thing when I was a junior. Also, knowing who to ask for help also helps a lot.
I stand by my statement. Code is easy and code is cheap. One day you'll understand.
It's not as if there are only startups and MNC, though.
My current company is very small, we're less than 15 developers. But it's a multi-tenancy B2B software that has, in some form or another, existed for 15 years, uses tons of outdated tech, where most of the original authors have long left the company, and so on. Getting up to speed with the code base and changing stuff is slow, but not because of organisational red tape - it's because it's really difficult to predict the impact of changes.
> I stand by my statement. Code is easy and code is cheap. One day you'll understand.
You don't have people under you that can complete in a year what you can complete in a month, and you're still insisting that anyone and their cat can code?
> I won't say they are worse at coding, but more that I am more familiar with how dependencies work because I've already done the same thing when I was a junior. Also, knowing who to ask for help also helps a lot.
I might phrase this a bit differently, but I think it’s getting at my thoughts as well.
I work with developers who would destroy me in a race to implement various search algorithms, or whatever discrete metric of coding prowess you want.
What they struggle with is:
- Efficiently getting other teams to answer their blocking questions in a way that makes the other team happy to work with them.
- Understanding the existing features of our fairly complex stack.
- Judging when to ask for help, and who to go to about a particular problem.
- Identifying dead ends quickly, and pivoting to alternative solutions at the first sign of trouble.
- Incorrect assumptions about the company’s priorities, and how the priorities can help shape the request.
I end up in a lot of meetings, but I also occasionally (a couple times a year on average,) take a few weeks and implement a business goal that a team has been stuck at for months/years.
Read: I'm (ironically) not good enough at communication to explain my point, so I'll just say a grandiose sentence to convince you I'm right without giving you any useful information.
Then you have quite limited experience (or you're just going for some snark).
Over my career I've seen all kinds of people leave coding. Some of them were poor coders and some of them were excellent. Some of them were good or bad communicators or architects.
Out of interest, just who do you think should be doing the high level architecture?
> Out of interest, just who do you think should be doing the high level architecture?
People who will maintain it have more interest in keeping it maintainable, rather than architects that won't actually do any of the work to maintain it, and will not learn from their mistakes.
I often see the argument that people who write the code should do the architecture as well. Maybe on a small development effort it can give better alignment.
When things scale up and in bigger orgs though, it doesn't work nearly so well. There are so many different business and technical requirements and strategies to take into account and signed off. This is a full time job. It may lead to really annoying things being imposed on the developers that they would never have chosen.
However, this does not mean that the architects are idiots, although that is of course possible!
At the company I work for, senior engineers are usually responsible for writing RFCs and getting the involved/dependent parties in the discussion, staff engineers chime in with architectural details the seniors might have missed due to a hyper-localised view of the issue/proposal. This feeds back into seniors understanding of the whole/higher-level architecture, which it's then used to adapt the proposals with the architectural decisions/requirements/constraints.
High-level architecture at scale demands a level of knowledge that engineers from a specific team might not have, not due to incompetence but because the scope of the team is bounded and the context is very local, at large enough orgs it's not possible even for senior engineers to keep track of all the weird interactions systems have at a higher level, you need someone whose job is to look at a higher level and validate cohesiveness, someone that knows about other similar work being done across other orgs to see points of cross-pollination, etc.
Honestly I can't see how I could depend only on myself and other senior engineers in my team to validate architectures that span cross-org, it'd be exhausting to shift my context all the way up and down architectural layers for every single RFC I write.
Domain experts, financial or business specialists.
I've never seen a competent software architect. They make wild statements, draw some trivial diagrams with impressive sounding words.
Then some diligent programmer discovers that none of it works, silently creates the real architecture. Then the "architect" takes credit for the result.
The days of Internet RFCs that are carefully written are over. We are in the age of agile self-promotion and B.S. (this also applies to foreign policy, with the same results).
Having senior dev / "architect" focusing on higher level / abstract design and working with junior dev to code it and get it up and running is a very common pattern in big company (especially not tech-first company). And it does work.
In truth, it is more a ad personam argument. You are not contributing anything substantial to the debate, you are just attacking dumpster_fire with no other argument than "in my experience".
The only data you provide is "your experience" which is of little value here considering we don't know the extent of it nor its relevance. If anything, the way you express your opinion so strongly, one would hesitate to think that you have any experience in a big corporation with several teams working on different product and/or part of the same product. The context in which having senior dev focus less on coding and more on reviews, documentation and design is common place.
We have the data that dumpster_fire thinks anyone can do coding, which tells us he's not well versed with it.
From there, by experience, people who aren't good juniors aren't good seniors. Good juniors might never become good seniors, but bad juniors won't be good seniors.
I don't see what my life history has to do with anything, when we have all the information right here :)
What data? I never said anyone can do coding. My spouse sure can't. Code is the easiest part of the job in my company where almost everyone is a genius (sans me). But few enjoy (nor do well with) syncing project goals with other teams. Someone has to do the dirty work while getting dissed by juniors for lack of code. I'm not sure if this experience applies to where you're working at so YMMV.
But I must admit that this is karma. For I have had an almost identical take as you more than a decade ago. Feels like I'm looking in a mirror.
Context is key here, but as a thought experiment- the most profitable businesses can hire with effectively no limit if they choose. FAANG isn't a great proxy for that but it'll do - assume their hiring bar is "can produce excellent code". Then what? Do you just allow everyone to heads down code? Principals and staff engineers rarely contribute directly to features because in their org context, with their expected level of staff - code is cheap and easy. Orchestrating decision making is very hard, and aligning technical to product outcomes is hard. How often are these businesses with huge budgets routinely criticised for poor releases? Yet their overall value remains enormous, because their cores are money printers.
Being an expert in the domain of writing code is relatively easy. Being a domain expert of your businesses value and the tradeoffs its making is very difficult. Just because people like the writing code part of the job doesn't make it the end game for the most valuable skillset.
Let me explain. Coding is the easiest because it's the most fun I get from my job. I don't have to talk to most people, I can have my alone time just writing code, cleaning it up, making it beautiful and lean, refactor as I like, whine about the unit tests taking more time than coding, and go home feeling like I've accomplished a lot. It's easy because that's all I have to focus on. Give it two weeks of junior devs telling me my coding style is outdated, and I've already adapted to the new meta.
System design at scale? Just trying to convince a separate team to work with us is a nightmare that I get insomnia from.
Coding is the easiest part of my job. FWIW I was just like you when I was a junior dev. Wondering why senior devs and engineering directors can't code. Now I know they can, but their time is better used to negotiate projects so that the junior devs can have their fun. Then I have to take time out to mentor junior devs on how to talk to people without being condescending, because that gets absolutely nothing accomplished in a large company.
Maybe the directors at your particular company can code. But a lot of them really don't. They don't understand the technical aspects of the problem and this results in bad decisions.
I've had someone who drives expensive cars tell me to change a simple line based streaming text format to XML to "make networking more unified across the company projects". He suggested to add a 120 KLOC XML library that does memory allocations right and left to our <10K line embedded project with soft real time requirements.
To set the level of experience, that same person claimed in the same meeting that UDP wouldn't lose packets on a local connection. And when I didn't obey he played a power game.
The better a product is factored, the more all aspects of development are interdependent. Creating isolated work packages leads to a badly factored product with lots of duplication, creating bloat and bugs and preventing important features and optimizations. That's why sometimes, small teams of really smart hard working guys can be extremely productive in comparison.
That said, team size can be increased, while smartness and hard workingness of the team can generally not be increased, and a lot of tasks can also just be grinded through, or they need to be grinded through because there is no realistic way to avoid it.
> Give it two weeks of junior devs telling me my coding style is outdated, and I've already adapted to the new meta.
Brilliant! I always say that I know how to code, I just need time to figure out how you code so I can match the style. "Adapt to the new meta" is a great way to put it :)
When I'm coding these days I feel guilty, like I'm wasting my time doing something fun when I should be doing real work!
At my former company, a 60 person startup, my CTO - a 55 year old guy - could code, design AWS architecture, do data analytics using Redshift (an OLAP database) and Athena (Apache Presto) and would often do POCs to research an idea and throw it over to wall to me to make it production ready.
It was a godsend when I was already overloaded with work and technology research. I was New when it came to cloud at the time.
On the other hand, his value add to the company and even to me wasn’t that he could code and design. He was a force multiplier by talking technical to our customers (B2B), mentoring, working with the owners, setting priorities based on the business needs etc.
I’ve had plenty of managers who could code and would rather spend fine coding than doing their job as a manager - career development, navigating through the political landscape, protecting their team from organizational bullshit and being “strategic”.
Coding is easy. At my current job in consulting, a hands on coding project is much easier than my more strategic consulting projects where I’m working with multiple teams, dealing with CTOs, CFOs, architecture review boards, dealing with fiefdoms where the “DevOps” team doesn’t want to give the developers the leeway they need to do their jobs efficiently and where tte developers want Admin access to everything and make a mess, etc.
That's a really bad faith take of that comment. I'd translate it as "in a place where most people are experienced programmers, communication becomes the main bottleneck."
Unfortunately I don't possess long range telepathic abilities, like you seem to have.
Ironically, it seems that even if your interpretation (or mind reading) is correct… we have someone that should be facilitating communication that is clearly not good at communicating what they are thinking.
Within the next 24 months that's what all engineers will transition to. Is it healthy or not, it's how it goes. Engineers move to abstract work like architecture, interfaces, and the implementation is handled by AIs, with humans just tweaking when it's not right.
I've played with code generation from AIs it works sometimes but confidently produces bugs and doesn't scale at all.
I think another giant leap is required to get to the point that humans are just tweaking. I'm saying we won't get there but what in the pipeline in the next 24 months that is going to get us there?
We all confidently write bugs and discover them in testing. The same process has been implemented for GPT, for example GPT Engineer, you can also instruct the Code Interpreter model for it in GPT Plus and it works. I see some people are not up to date here.
What I base my guess on: the fact we already have GPT apps that write apps and clearly it works fine, and as we like to say "this is the worst it'll ever be". When people say "it's not very good right now, it produces garbage" I only see people who are not used with the speed of progress right now. Midjourney a year ago produced weird abstract doodles that only looked like images from distance. Now it produces photorealistic art that's taking jobs. One year.
What we need: Bigger context, expert models in constellation and scale. You need nothing else. Of course some architectural modifications will emerge in the journey of achieving this, but that's a comparatively trivial constraint to solve, it's just normal software engineering as we've done for decades, but this time for models.
First: the AI isn't that accurate yet. It gets shit wrong. It's almost there but not yet. Maybe in 24 months... but a lot of people think we hit a wall.
Second: implementation is harder then design. If AI can do implementation it can for sure do design. And it is demonstrably true that chatGPT can do design just as well if not better than implementation.
My observations are literally the opposite of what you said so YMMV. Design is where the needs of humans interface with the needs of a machine. Models are good at translating basic needs to code. Not so great knowing or figuring those needs in wider context. Yet. They’re interns.
We also had apps written by "non coders" in excel. We had apps written by some hackthon participants who hadn't coded at all a week before the hackathon. Writing the code is not the hard part of software development, and never has been.
The various LLMs do very poorly at generating and implementing high level designs, especially if they need to generate the specs themselves from a bunch a requirements and/or poorly formulated user feedback.
You’re reiterating his argument almost perfectly. He initially said the code writing will be left to the AIs while high level designs will be left to the engineers. That’s exactly what they mention foreseeing in the next 24 months, which I also intuitively agree with.
Do the AI's need those things? I mean, they exist so that humans can understand their 10 million line code bases. Maybe something else will be needed, for AI's to understand their 10 billion line code bases. Something that we won't even be able to discern.
