Software development is evolving

Software development is evolving. Writing code is becoming a commodity partially, nevertheless i think that last 20% of the code details is what makes or breaks a software business.

Reviewing the code with the intention to understand it, not just review "superficially", it is something of utmost importance nowadays.

Previously we were reviewing code of other people and that was a much lower volume of code. Now there is much more code to review , much more often. Just the process of writing code requires scrutinized review before even opening a pull request. Now the duty of the developer opening the PR is to do review continuously until a good judgement is made that can then be sent for Peer Review in the form of a Pull Request.

Developer role is morphing from Writer/Editor at 50% / 50% to 20% / 80%. I don't see it as software becoming easier, I just see it as another kind of prioritization and tasks. In writing we needed deep thinking focus , now we need that with additional mental agility to switch focus and get deep into new topics faster. There is no way around it , if you want quality, you need to understand what the system does.

When I said previously review was "superficial" in quotes, I say that for lack of a better word. What I mean is previously we had some more context as reviewers on who wrote the code and what did that developer deliver in the past, so we could also have Trust playing a role in the review process or at least a human (much more complex intelligence than LLM, if LLM can even be considered intelligent) that we could ask and get a better distilled understanding of their judgement.

The landscape is changing at an uncontrolled and never before seen pace and many things are rushed. The opportunities are now seemingly easier to spot and do a Proof of Concept, nevertheless if after POC, it is determined that the idea is valuable and hits gold then that has to be refined meticulously into Value instead of just Raw Material. The output product will be given to customers who will pay for solutions and they will not agree to pay for subpar solutions they could have scrambled themselves. The difference maybe will be made by those that really understand the value of code ownership and that AI is just a tool, an autocomplete on steroids.

On the one hand I think this is a wave that will crash badly and will leave many in need of help, we developers will always be there to help.

On the other hand I think this is a wave to be ridden, just be careful and see the wave for what it is and the dangers it brings along with the benefits.

I am a curious developer that would like to see how other devs and other disciplines are adapting to this wave, how different perspectives think about this transformation!

---

From the comments

I agree that a big part of the code is unnecessary overengineering, sometimes (failed) experimentation of the developer wanting to try out new things. On the one side AI code generation gets rid of experimentation because it tends to statistically use well known patterns when guided well, on the other side it stifles innovation because all code will converge to same patterns.

AI when left unguided also tends to overengineer and make code overly abstract (but that also some devs do). I would say the problem just got amplified in a way. There is now much more code written. The problem is that the code written now does not come from a deep thinking and tinkering mind.

Nevertheless it is starting to feel like it is impossible to stick to artisanal way of coding, seems like a mixed approach where we devs do the deep thinking, architecture decisions, reviewing of quality and tinkering with the output. It is really astonishing how much is changing and how fast.