As a “baby” computer scientist (or software engineer) or someone about to choose this career, you might feel overwhelmed by the sheer firepower of these new LLMs.

The real gap, however, lies in experience, not in firepower.

These LLMs have seen millions, if not billions, of lines of code—probably at least three orders of magnitude more than the amount of code you will encounter in the next 40 years of your career.

Surely, they must have better solutions than anything you could ever come up with, right? Not quite. Let me explain.

Professional Intuition vs Algorithmic Responses

When we talk about professional intuition versus algorithmic responses, we’re addressing a fundamental difference in how humans and LLMs approach programming challenges. Let me break this down in detail.

Professional Intuition in Software Development

Professional intuition in software development is like a sixth sense that developers cultivate over years of hands-on experience. Imagine a senior developer who, within minutes of looking at a bug report, can narrow down the likely cause not because they’ve memorized every line of code, but because they’ve developed a deep understanding of how systems typically fail. This intuition comes from a rich tapestry of experiences: the late-night debugging sessions, the production incidents that required quick thinking, and the countless conversations with users and stakeholders.

Consider this real-world scenario: A system suddenly starts experiencing intermittent performance issues. An LLM, when presented with the error logs and code snippets, might suggest various optimization techniques based on pattern matching from its training data. However, a seasoned developer might immediately suspect an interaction with a recent business event—perhaps a marketing campaign that changed user behavior patterns—because they understand the broader context in which the code operates.

Key Aspects of Professional Intuition

This intuition manifests in several key ways:

Understanding System Behavior Under Stress

Through experience, developers develop an almost instinctive sense of how systems behave under different conditions. They can often predict cascade failures before they happen, not because they’ve calculated every possibility, but because they’ve developed a deep understanding of system dependencies and potential failure points.

Context-Aware Problem Solving

When developers debug issues, they don’t just look at the code in isolation. They consider factors like recent deployments, user behavior patterns, business events, and even the time of year (think holiday season traffic spikes). This holistic view is something that LLMs, despite their vast knowledge, cannot replicate because they lack real-world operational context.

Risk Assessment

Perhaps most importantly, developers have an innate sense of risk that comes from real consequences. They understand that every line of code they write could potentially affect real users, business operations, and system stability. This understanding isn’t just theoretical—it’s deeply personal and comes from experiencing both successes and failures.

A Concrete Example

Imagine developing a payment processing system. An LLM might suggest perfectly valid code for handling transactions, complete with error handling and logging. However, a developer with experience in financial systems would instinctively add additional safeguards against double-charging, implement idempotency patterns, and ensure proper reconciliation mechanisms—not because these were explicitly requested, but because experience has taught them these are critical in financial systems.

The Role of LLMs in Development

This doesn’t mean LLMs aren’t valuable—quite the opposite. When we understand that LLMs are pattern-matching tools rather than intuitive problem solvers, we can better leverage their strengths while relying on our intuition for the crucial decisions that require deep understanding and context. The key is recognizing that our intuition isn’t threatened by LLMs but rather becomes more valuable as it helps us better utilize these tools.

Strengthening Professional Intuition

The development of this professional intuition is ongoing and actually accelerates when working with LLMs. While the AI can handle routine coding tasks, we can focus on developing our understanding of system architectures, business domains, and user needs—areas where human intuition remains irreplaceable.

Nowadays, there’s a lot of talk about LLMs (large language models), often in connection with the concept of AGI (Artificial General Intelligence). AGI represents the challenge of creating a general-purpose AI capable of doing everything as well as humans—or even better, in the case of ASI (Artificial Super Intelligence).
Notable experiments have already emerged, one of the most famous being Baby AGI.

The question I’d like to raise is the following:

Are we sure a language model is what will lead us to this goal?

They predict, they don’t think.

I ask because many overlook a fundamental and self-evident concept: these models don’t think.
What these models do is one of the most classic tasks in AI: they predict a value. They analyze the “past” and, after a seemingly infinite series of matrix multiplications, output a bunch of values between 0 and 1, picking the token with the highest probability.

They do it well, they do it efficiently. But they don’t reason.

For instance, they know that 2+2=4 simply because, countless times in the training dataset, the characters “2,” “+,” “2,” and “=” were always followed by the character “4.” For fans of alternative rock, there’s also “5”.
And what if the model’s creators were big fans of alternative rock? We might have ended up with a ChatGPT where 2+2=5. In fact, early versions of ChatGPT didn’t know how to handle math at all. And even now, it’s not guaranteed that it truly understands math, it’s highly likely that an external logic kicks in whenever math is required.

Some might argue that reasoning is nothing more than predicting the next thing to say or think.
I respond by saying that art and even problem-solving wouldn’t exist if the very concept of reasoning were so simplistic.
Art —in all its forms, including programming — is a generative process. It doesn’t predict the “next thing to do” based on something already known (e.g., 2+2=), but it creates the next action, attempting not to resemble something already familiar.
A language model doesn’t do this; it cannot invent something new. Everything that comes out of its final layer is just a number associated with a token it already knows. It’s a closed world.

Moreover, LLMs have a very basic limitation: they know what they’re about to say and what they’ve already said, but not what they will say in the next few words. This is why models like GPT sometimes repeat themselves. They lack what, in the world of Regular Expressions, is called a “positive lookahead.”

Accepting that an LLM could be AGI means admitting that we have nothing left to discover and that if something remains unknown, it’s only because human inductive reasoning hasn’t yet reached that conclusion.
I really like this image to describe what I mean:

An LLM stops at knowledge. A human has the power of intuition and even error. Without error, there would be no penicillin; without intuition, there would be nothing.

Hi there! I’m Matteo Notaro (he/him), an Italian tech enthusiast with what might seem like an ordinary passion: everything related to technology. I love programming, problem-solving, and basically anything that rhymes with “tech.” Oh, and I’m a huge fan of 🍕 and ☕ – but I guess that’s pretty standard for someone living in the Bel Paese.

Jokes aside, my journey in the tech world began quite conventionally: I earned my bachelor’s degree in Computer Science from the University of Calabria in 2020, right in the middle of a global pandemic. It was a challenging time, for sure, but also incredibly stimulating.

My Educational Journey

During my bachelor’s studies, I was lucky enough to participate in an Erasmus+ project in Klagenfurt am Wörthersee, Austria. While there, I began working on my thesis, developing a parser for a programming language based on Answer Set Programming. Not satisfied with the result, I decided to push further: I turned that project into an IDE-as-a-Service. The result? A degree with top honors (110/110 cum laude) and an experience I’m still proud of today.

After earning my bachelor’s, I pursued a master’s degree in Artificial Intelligence and Data Science. However, I eventually decided to shift gears and completed my master’s in Computer Engineering at UniMarconi.

My Professional Experiences

I started working during high school, taking on small web development projects. Nothing groundbreaking – mostly WordPress here and there – but these projects helped me take my first steps in the field.

In 2020, one of my professors offered me a position in a spin-off company of the University of Calabria. After a few months working part-time, I seized the opportunity to work full-time as a developer. That’s where my career truly began, primarily as a full-stack developer working with Angular, Spring Boot, and SQL databases.

The real turning point came when I discovered the world of Big Data. Apache Spark, Scala, and NoSQL databases opened up a fascinating universe that motivated me to dig deeper. Along the way, I also explored DevOps tools like Docker, Kubernetes, and Jenkins – because why not keep things exciting?

One project I’m particularly proud of is DataGan, a system for generating synthetic data based on production data. The idea was mine, and it grew into a full-fledged company project.

In my most recent role, I held the title of Head of R&D. Unfortunately, the reality didn’t match the promise of the title, and I realized it wasn’t the right place for my professional growth.
After realizing that, I changed company, drawn by the promise of exciting projects in the AI field. However, once in the new one, I found myself working on uninspiring web development tasks for products with little technological appeal and poorly managed workflows. For 10 out of the 11 months I spent there, I felt underutilized and unchallenged, struggling to find any real engagement in my work.

Since November 2024, I’ve been working at Agile Lab, where I hope to continue building innovative projects in AI and data.

What Drives Me

If I had to summarize what motivates me in one word, it would be creation. Creating solutions to complex problems, building useful tools, and, why not, stirring up some creative chaos when needed. I love diving into challenging new technologies, learning, and constantly improving.

Why Am I Writing This Blog?

This blog is my space to share experiences, ideas, and projects. Whether you’re here for inspiration, curiosity, or just to laugh at a few tech anecdotes, I’m glad you stopped by.

If you’d like to share thoughts, collaborate on a project, or just chat about technology (or pizza and coffee), feel free to reach out!

Thanks for reading, and happy hacking! 😊

• Datagan: tool for generating synthetic data. Not in my possession right now.
• Pythia: Pythia is a tool designed to automatically generate docstrings for Python files using the power of large language models (LLMs). By analyzing your Python code, Pythia creates detailed and accurate documentation for functions and classes, making your code more understandable and maintainable.
• ASPIDEaS: an IDE as Service for Answer Set Programming.