If you've read my posts before, thank you. I usually write about building models and the maths behind them, but this one is about something that will affect every developer over the next few years: agentic AI.
When Google announced Gemini 3 alongside Antigravity, its agent-first development environment, the reaction among programmers I know was intense. More than one friend said some version of:
"This is the end of jobs!"
I don't agree, but I understand the fear. So I wanted to break down what agentic AI actually is, what Antigravity can and can't do (I tested it), and what all of this really means for a career in software.
What is agentic AI?
Agentic AI refers to systems that don't just answer questions. They plan, carry out tasks, make decisions and work towards a goal on their own.
A traditional AI tool responds when you prompt it. An agentic system can:
- plan a sequence of tasks,
- carry them out across several tools (the editor, the terminal, the browser),
- check the results and change its approach, and
- do all of that with very little human supervision.
That's why businesses are paying attention: an agent that reliably handles routine work is very appealing. It also raises fair questions about jobs, code quality and long-term maintainability.
How agentic AI really changes teams
Let's be direct: AI raises productivity. A team of 20 engineers with strong AI tools might deliver what a team of 30 could a few years ago. That doesn't automatically mean mass layoffs, but it does mean teams will reorganise around the people who use AI well.
There's a flip side. Used carelessly, AI creates long-term problems, especially when developers lean on tools they don't fully understand. One risk stands above the rest:
If your team can't understand or maintain the AI-generated codebase, your product becomes fragile.
AI can speed development up, but without human oversight, architectural consistency and maintainability are the first things to go.
So the message isn't "AI will destroy jobs". It's this: AI will reward developers who know how to use it, and it will expose the gaps of those who don't.
What is Google Antigravity?
Antigravity is Google's agent-first development platform, launched with Gemini 3 in November 2025. It's built to let AI agents do real software-engineering work across your editor, terminal and browser.
It lets Gemini 3 write, change, test and run code on its own, and it introduces Artifacts: a transparent record of what the agent is doing, so you can inspect its plan and its work instead of trusting a black box.
What it can do
From Google's demos and documentation, Antigravity can:
- scaffold an application from a plain-language prompt,
- debug and refactor existing code,
- run commands in an integrated terminal, and
- verify its own output and adjust automatically.
It's powerful, but it isn't magic. One prompt does not produce production-ready code. Human review and several rounds of refinement are still essential.
Who it's really for
Antigravity shines in the hands of experienced developers: people who understand the underlying technologies, can tell when the agent's output is right or subtly wrong, and know when to correct or override its decisions. In other words:
Antigravity multiplies expertise. It doesn't replace it.
What I learned testing it
I tested Antigravity by having it generate a complete portfolio website with React, a Django backend and OTP authentication. It produced a working first draft quickly, and that was genuinely impressive.
It also showed me some practical limits:
- Specific UI and UX requirements took careful prompting and several iterations.
- AI-generated code can be harder to edit than code you wrote yourself, because you don't carry its structure in your head.
- For larger changes, it often felt faster to rewrite a section by hand than to keep prompting.
Here's where I'd use it, and where I wouldn't:
| Where it excels | Where it falls short |
|---|---|
| Prototypes | Production systems where maintainability is critical |
| Throwaway code | Specialised domains that need deep understanding |
| Internal tools | Code that will live and evolve for years |
| Rapid iteration |
A word for beginners
Here's my honest take: if you're a student or early in your career, don't use Antigravity to write your main code.
Not because AI is dangerous, but because learning needs the very things an agent takes away:
- debugging problems yourself,
- troubleshooting and experimenting,
- the productive struggle with hard concepts,
- writing, rewriting and iterating, and
- understanding architecture from first principles.
Skip those and you skip the experiences that turn you into an engineer. Use AI to accelerate your learning, not to avoid it. Once the fundamentals are solid, you can use tools like Antigravity responsibly and with confidence.
The bigger picture
What matters most is this: agentic AI can amplify a strong engineering culture, but it can't replace one.
A start-up that fires experienced people recklessly, depends entirely on AI output and skips human review will still hit the same walls: maintainability collapses, technical debt piles up, nobody is providing critical oversight, and wrong assumptions get baked into the code.
Tools don't fix organisational problems. People do.
Final thoughts
Agentic AI, and Gemini 3 with Antigravity in particular, is a real leap forward. It will reshape how we build software, how we learn, and how teams work. But here's what I believe:
- AI won't replace skilled developers.
- Developers who master AI will outpace those who don't.
- Companies that deploy AI recklessly may move faster at first, but they won't necessarily last longer.
The path forward is clear: learn the fundamentals, use AI wisely, and remember that human experience is still irreplaceable.
I later turned these ideas into a concrete, research-backed workflow in Stop Vibe Coding. Are you excited about agentic AI, or worried? I'd like to hear which, and why, on LinkedIn.