AGI Isn't Here. So What Actually Works?

No, AGI is not here. Anyone who tells you it is, or that it’s just one breakthrough away, is probably selling you something.

It’s a boring answer, but it’s the truth. We’ve made incredible progress in building systems that mimic intelligent behavior, but we’re still miles away from creating a machine with the general, adaptable, common-sense reasoning of a human.

Forget the sci-fi fantasies of self-aware robots. The real conversation is about what today’s Large Language Models (LLMs) can actually do for you, right now. And, just as importantly, where they fall flat on their face.

Masters of the Matrix

Today's AI is a pattern-matching engine on steroids. It has ingested a massive chunk of the internet and can recall, remix, and restructure that information at a scale that feels superhuman. Because it is.

This makes it phenomenal at specific tasks:

• Code Generation & Refactoring: You can throw a messy Python function at GPT-4o and ask it to refactor it for clarity and efficiency. It will almost always give you a cleaner, more idiomatic version back. It's a brilliant pair programmer for tasks it's seen a million times before.
• Summarization & Synthesis: Got a 50-page academic paper on quantum computing? You can ask Claude 3 to summarize the key findings in five bullet points, and it will do a better job than a grad student pulling an all-nighter. It synthesizes known information flawlessly.
• Translation & Transformation: Need to convert a JSON object into a YAML configuration file? Or translate a user story from English into a Gherkin feature file? Models excel at these structured data transformations because they are pure pattern recognition.

Here’s a concrete example. I fed it a clunky, hard-to-read SQL query:

SELECT u.id, u.name, p.profile_url FROM users u JOIN profiles p ON u.id = p.user_id WHERE u.signup_date > '2023-01-01' AND (SELECT count(*) FROM orders o WHERE o.user_id = u.id) > 5;

And asked it to "make this SQL more readable and performant using a CTE." It immediately came back with:

WITH UserOrders AS (
  SELECT
    user_id,
    COUNT(id) AS order_count
  FROM orders
  GROUP BY user_id
)
SELECT
  u.id,
  u.name,
  p.profile_url
FROM users u
JOIN profiles p ON u.id = p.user_id
JOIN UserOrders uo ON u.id = uo.user_id
WHERE u.signup_date > '2023-01-01'
  AND uo.order_count > 5;

That’s genuinely useful. It’s not thinking; it’s recognizing a common, superior pattern for a given problem. This is the sweet spot.

The Ghost in the Machine is Just an Echo

Where does it all break down? The moment you ask the model to do something that requires genuine reasoning, planning, or understanding of cause and effect. LLMs are expert mimics, but they have no underlying model of the world.

They fail spectacularly at tasks requiring:

• Causal Reasoning: Ask a model why a project is late, and it will give you a plausible-sounding list of reasons it has seen in its training data (scope creep, resource shortage). It can't look at your Jira board and your GitHub commits and deduce the actual novel reason your specific project is behind schedule.
• Long-Term Planning: Ask an AI to “build me a SaaS app for pet-sitters.” It can generate a decent project plan or write a single component. It cannot hold the entire complex state of the project in its head, make strategic trade-offs over weeks, and adapt to unforeseen problems. It can’t maintain a coherent goal over thousands of steps.
• Physical Intuition: Models don't understand the real world. A famous example is asking one, “If I have a box of chocolates, a book, and a laptop, and I put the chocolates in the fridge, then move the laptop to the sofa, where are the chocolates?” It might get it right, but it can also be easily confused because it doesn't have a mental model of object permanence. It's just predicting words.

These aren't bugs to be fixed. They are fundamental limitations of the current architecture. The model doesn’t know anything. It just knows what words are likely to follow other words in a given context.

A Practical Turing Test for Developers

So, what would a real AGI look like? Forget consciousness or passing for human in a chatroom. I propose a more practical benchmark for what we might call “Useful General Intelligence.”

Here's the test: Can I give the AI a high-level business goal, access to a codebase, the necessary APIs, and a cloud account, and have it autonomously produce a working, deployed feature that accomplishes the goal?

This would require it to:

1. Understand the ambiguous goal ("Improve user retention").
2. Formulate a plan (e.g., "I will build a weekly summary email").
3. Read and understand the existing codebase.
4. Write new, correct, and integrated code.
5. Use tools (Git, Docker, AWS CLI) to test and deploy its own code.
6. Monitor the results and iterate on its solution.

We are nowhere near this. Current AI agents can perform a few steps in a controlled environment, but they get stuck, hallucinate, and require constant human intervention. They are tools, not autonomous colleagues.

Build Agents, Not Oracles

Instead of waiting for AGI, the smart move is to lean into what today’s models are good at. The future isn't a single, all-knowing oracle. It's a system of specialized, AI-powered tools that we direct.

This means building agentic workflows. Create small, focused agents that do one thing well: an agent to triage bug reports, an agent to draft API documentation from code, an agent to optimize your database queries. You, the human, remain the strategist, the planner, and the one who understands the why.

Stop asking, “Is this AI smart?” Start asking, “Is this tool useful?” Right now, the answer is a resounding yes—as long as you’re the one holding the leash.