Thoughts on Developing With A(ccelerated) I(nference)

AI stands for artificial intelligence, yet I prefer the term Dr. Venkat Subramaniam used in one of his talks: Accelerated Inference. To my mind, it is far more accurate, so I have embraced it.

And “accelerated” is precisely the point. With AI, generating code has become cheap; it is no longer the bottleneck of software development. What has become expensive, and what this article is really about, is everything around it: aligning outcomes with intent, owning what we ship, and exercising the judgment that no amount of acceleration can replace.

A Brief History

The main structures underlying modern AI are neural networks and transformers — statistical models capable of replicating patterns. The former have been around for much longer than many people today assume; the latter are comparatively new.

The field’s milestones trace a recurring cycle of bold ideas, disillusionment, and breakthroughs driven by new algorithms, more data, and faster hardware: from the first mathematical model of an artificial neuron (1943) and the perceptron (1958), through the first “AI winter” (1969) and the backpropagation revival (1986), to AlexNet’s deep learning breakthrough (2012) and the Transformer architecture (2017) that underpins all modern large language models.

In other words, AI as a concept is not new at all. What is new is that today almost everyone, technical or not, has an opinion about AI and how it is changing the way we work.

On one hand, this is perfectly normal: the world isn’t what it used to be, the available tools are different and more powerful, and certain problems can now be solved much faster. On the other hand, in this new and fashionable landscape, people should strive to form objective opinions first, filter them through their own judgment, and only then express and apply what proves useful. From individual to individual, hasn’t this always been the case with everything else?

Habits Worth Keeping (and Acquiring)

When it comes to people, the recommendations on how to act when ‘newness’ emerges haven’t changed from what we’ve been used to. Certain responsibilities and habits should be kept, others adapted and continually improved, while new ones acquired. Regarding software engineers, I feel slightly more entitled to an opinion; thus, here are a few pieces of advice I have compiled and consider worth having close.

• Before writing code, strive to turn incomplete and ambiguous requirements into a comprehensible starting point — understand not just how to build something, but why and who it serves.
• Before writing code, know when to use a certain algorithm or design, why it matters, and how it fits into the large application you are building.
• Before merging in your code, have it reviewed first by yourself, then by at least one human programmer.
• Get used to a shift in thinking. Engineers are used to predictable results; LLMs produce variable output. A switch from deterministic to probabilistic thinking may be needed.
• Before merging AI-generated code, review every line in detail and thoroughly understand why each decision was made - transform the changes into fully owned ones, as if you had written them yourself. (sounds familiar, doesn’t it?)
• Before merging AI-generated code, make sure it meets the project’s coding standards and remains human-readable, and improve it where possible.
• Sharpen your code-reading and reviewing skills. They were always a plus; now that AI agents are programming buddies producing large volumes of output, they are essential.
• Avoid “prompt-and-pray vibe coding.” Use AI thoughtfully, maintain rigorous standards, and don’t short-circuit your own learning.
• Use AI as a force multiplier to amplify your existing skills — knowledge, experience, problem-solving as a professional, and above all, objective, constructive judgment as a human being.
• Validate both directions. Check not only what AI agents produce as output, but also what they consume as “trusted” input.
• Co-build abstractions. Use LLMs to help build an abstraction, then use that abstraction to communicate with the LLM more effectively and solve problems in a more deterministic manner.
• Keep delivering reliable, maintainable software, but pay closer attention to how you spend your time building it.

Some of these points are about AI; some are not. Some have been acknowledged for ages; others emerged recently and will be assimilated sooner or later.

From Writing Code to Solving Problems

One thing is certain: with AI, the software development approach and mindset are fundamentally different. In this shift, I believe software engineers have a great opportunity — to move their attention even further from writing code to solving problems, and to spend their energy on more meaningful challenges. Oleg Koverznev puts the thesis I opened with even more sharply: “… code generation is cheap and no longer a bottleneck; the real challenge is aligning outcomes with intent, along with managing the growing operational and economic complexity of agent-driven work.”

AI's instant output tends to fuel our impatient expectations for immediate results. It can make us feel productive and efficient, but let's hold on for a moment, resist the rush, and ask whether the outcome has real value, whether it actually produces impact.

Going deeper, there is an idea I find helpful in sustaining this point of view. Luciano Floridi — a leading figure in the philosophy of information and digital ethics, widely influential in AI ethics - has a thesis (sometimes referred to as Floridi's Conjecture) that can be summarized as follows:

As the complexity of a system increases, the ethical significance of its interactions also increases, while the ability to fully predict or control its behavior decreases.

In this view, advanced information technologies are re-ontologizing our world, reshaping the very fabric of reality and our place within it, rather than simply serving as tools within an unchanged reality. Applied to AI, the conjecture suggests that a fully autonomous system cannot have great scope and great certainty at the same time; AI agents will therefore always require human oversight. Yet more and more, out of convenience, people tend toward fully embracing agent autonomy, when it would be wiser to remain in the loop: tempered and watchful. 

Language, Thought, and Staying Sane

Science in general and AI in this particular context is not a magic trick, but a special way of using human intelligence. We embrace science and AI not when we put on a white coat, but when we start practicing a set of canons of thought, many of which have to do with the use of natural language, which is, after all, the main medium of AI-human interaction.

New technologies change what we understand by “knowledge” and “truth.” They alter the deeply rooted habits of thought that give us a sense of the world, of the natural order of things, of what is reasonable, necessary, inevitable, or real. The actual magnitude of the effect varies from person to person. But as Neil Postman observed, a new technology doesn’t merely add or subtract something — it changes everything. It redefines the words by which we guide our lives: freedom, truth, intelligence, reality, wisdom, memory, history. And it never stops to warn us, and we never stop to ask. We keep rushing.

Conclusion

In these days when AI seems to be the solution for almost everything, I consider it very important to keep improving our reading, writing, and technical skills, our natural language, and our critical thinking, and to apply them wisely. To be respectful to ourselves and to others. To value truth more than mere correctness and, why not, to become good bullshit detectors as well. In a world where consumerism is amplified as never before, where objects are overvalued and abundant, and where speed is prized over competence and quality, remaining sane is a real virtue.

Improving our human virtues is a continuous and tedious process, but a rewarding, fundamental, and safe one in the long run. Let’s not change the world, let’s change ourselves.