We, as developers, traditionally start building software to reduce uncertainty and enforce determinism for solutions and systems. Classic software engineering tries to have the same output for the same inputs. While doing this, we build software with some explicit logic and traceable behaviors to make outcomes deterministic.
But now we’re using non-deterministic systems (LLMs, agents) to build those deterministic solutions and systems. This is very interesting…or maybe not.
As humans, we are also non-deterministic living beings. We trust people to build deterministic systems. So, maybe it is not so interesting to rely on AI to build software. In this aspect, AI tools/platforms are just a new collaborator.
Who knows more: the one who reads a lot or the one who travels a lot?
There is a very cliche question; “Who knows more: the one who reads a lot or the one who travels a lot?” But good one to define AI tools. AI tools/platforms are just collaborators who read a lot; I mean “really” a lot. But they are not experiencing as someone who travelled a lot. So, they don’t have knowledge as we really feel. Because of AI’s nature, “reading a lot” does not mean they also know “a lot”. By nature, they are just curators. They just assemble some already produced pieces perfectly to generate an artifact.
Having those artifacts and collaborations in our solutions changes some paradigms in software development.
While developing software solutions, with humans, we can ask “why” or we can challenge “reasonings” (a.k.a assumptions) or we can manage trust.
But with AI, we are getting confident-looking outputs. We cannot know or be sure how initial reasoning is done. At we cannot easily manage their reliability for similar occasions.
Having AI generated artifacts might cause us to lose understanding of our own solutions.
And because of this risk, having AI artifacts creates a new developer’s reasonability. As developers, until now, we have been authors of what code we write. But with AI collaborators, now we are more like explicit curators, debuggers and verifiers. Having some math formulas make posts more serious 😊 ; so, now we define “developers” as
developer = curator+ debugger + (10 x verifier)
Now it seems our role shifts more toward verifying correctness, operational characteristics, security concerns, domain constraints…etc.; lots of things… And those things are also some already decided and presented concerns while we are developing some solutions. Now, the way of providing those is changing. Previously we were implementing “those”, now we are verifying “those” if they are implemented as expected.
A paradigm shift…
It feels like a meaningful paradigm shift. Now we are moving from “I built this” to “I am responsible for this”. So, a developer is not just a coder, but they are some kind of governor for the solutions. And this change will introduce new challenges and new opportunities as well. But I am not sure if this will make developers live easier…Maybe this will make production easier but also responsibility heaver.
To survive or to live with this new paradigm shift, as developer, I guess, we need to learn how things work much better than before. Here are some key points that I think we need to challenge more;
- Knowing how LLMs work
- How skills, instructions, agents defined for effective results
- Getting strong about architectural patterns
- Core pillars and principles about the technology that we depend on
- Be good at writing, precise meanings and descriptions
- Assuming generated code as guilty until proven innocent
- Never ending refactoring
- Making everything visible, no hidden or unknown parts
- Treat “prompts” as code
- Much more test cases and scenarios
- Cost; both operational and financial cost of having AI collaborators
Other than tools and processes, this new paradigm shift will also change the behaviors of developers. Let’s see how we as developers will evolve within time…We may write less code, but we may need to understand more than ever. Maybe the real skill of the future developer is not writing code, but understanding responsibility.
Let’s see…
