Is It AGI Yet? A Sober Look at What LLMs Can't Do

Let's get this out of the way: No, we do not have Artificial General Intelligence. We are not close.

The breathless demos and sci-fi headlines are selling a story that doesn't match the reality of using these tools day-to-day. As developers, we need to be ruthlessly pragmatic. Hype doesn't ship products, but understanding a tool's sharp edges does.

Modern Large Language Models (LLMs) like GPT-4 and Claude 3 are amazing. They are also fundamentally limited. Confusing their fluency with genuine intelligence is a trap. Let's look at what they actually do well, where they fall apart, and how we should be thinking about them.

What Today's Models Nail

There's no denying the magic. When you see a model transform a messy chunk of text into perfect JSON, or write Python boilerplate in seconds, it feels like a massive leap. And it is.

Where they excel is in manipulating and restructuring information based on patterns learned from a truly colossal dataset. They are masters of:

• Text Transformation: This is their core superpower. Summarizing articles, translating languages, changing tone, or reformatting data is trivial. Need to convert a user's rambling email into structured data for your backend? An LLM is your best friend.

# A simple API call can do complex reformatting
curl https://api.openai.com/v1/chat/completions -H "Authorization: Bearer $OPENAI_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "gpt-4-turbo",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant that converts unstructured text to JSON."
    },
    {
      "role": "user",
      "content": "The user is Jane Doe, her id is jd345 and the ticket is about a broken login button. Priority high."
    }
  ]
}'

• Code Generation: Tools like GitHub Copilot are now indispensable for many developers. They’re fantastic for writing boilerplate, generating unit tests, or suggesting how to use an unfamiliar library. They act as an infinitely patient pair programmer who has read all of Stack Overflow.

• Synthesis and Brainstorming: LLMs can connect dots across different domains in ways that are hard for us. You can ask, "Explain Kubernetes networking using analogies from ancient Rome," and get a surprisingly useful answer. It's a powerful tool for getting unstuck.

But notice the theme. All these successes involve remixing, reformatting, and retrieving existing information. They are autocomplete on a god-like scale. The problem starts when we ask them to do more than that.

The Cracks in the Facade

The illusion of intelligence shatters when you push the models beyond pattern matching into territory that requires genuine reasoning, planning, or an understanding of the world.

This isn't about esoteric edge cases. These are fundamental failures.

Ask a model a simple logic puzzle that requires tracking relationships: "John is taller than Dave. Dave is shorter than Mike. Who is the tallest?" It might get it right, but slightly increase the complexity and it will confidently give you a wrong answer, because it's predicting words, not reasoning about the relationships.

Then there's the physical world. LLMs have no grounding in reality. They've read about gravity, but they don't understand it. Ask one for instructions on how to build a stable tower out of a book, a wine glass, and a banana, and it will give you generic, plausible-sounding steps that ignore the actual physical properties of the objects. It has no common sense.

Long-term consistency is another massive hurdle. Even with huge context windows like Claude 3's 200k tokens, they can't maintain a coherent plan or memory over a long project. The model doesn't "remember" turn #5 in the same way you do; it just re-processes it as part of a new prompt. This makes it impossible for an LLM to autonomously manage a complex, multi-day software project.

And we have to talk about hallucinations. Models invent facts, API functions, and command-line flags with absolute confidence. This isn't a bug to be ironed out; it's a feature of a system designed to generate probable text. For any task where factual accuracy is non-negotiable, you still need a human expert to verify everything.

A Better Frame: Specialized Tools

"AGI" is the wrong lens. It creates a false expectation of a general-purpose intellect that can think, reason, and learn like a human. That’s not what these are.

A better way to think of them is as incredibly powerful, specialized tools. A calculator is superhuman at arithmetic, but we don't worry it's going to achieve consciousness. An LLM is superhuman at manipulating text.

They are universal text-processing engines. Instead of asking, "How can I build an AI to manage my customer support?" try asking, "Which parts of my customer support workflow can be automated with a text-processing API?"

This reframing turns you from a frustrated dreamer into an effective engineer. You can build amazing things by focusing on the specific tasks where the tool shines:

• Classification: Is this email a sales lead or a support ticket?
• Extraction: Pull the names, dates, and amounts from this invoice.
• Summarization: Give me the five key points from this 2-hour meeting transcript.
• Drafting: Write a first draft of a marketing email based on these bullet points.

These are valuable, time-saving applications that are possible right now. They don't require AGI.

The Path Forward

Simply scaling up current architectures—more data, more compute—will make them better at what they already do. It will produce more fluent text and more accurate patterns. It is unlikely to magically create true reasoning or a model of the world.

That breakthrough will probably come from a different approach, maybe a hybrid of neural nets and symbolic reasoning. But that's a long way off.

For now, stop worrying about AGI. Start mastering the incredible tool you have in front of you. Understand its strengths, respect its weaknesses, and build useful things. The revolution is already here, it's just not the one you saw in the movies.