Can AI take my job?

And the orchestration agent acknowledging skills:

Why Agentic AI

Most “AI coding” discussions still assume a single prompt → single response loop.

Agentic tools change that. Tools like Goose or OpenAI’s Agents can plan work, maintain state, use tools like GitHub, Figma MCP, Storyblok, and Vercel, and iterate over time.

This matters, because real software engineering isn’t about typing code. It’s about sequencing work and managing complexity.

But early on, the agent struggled to operate autonomously. The brief was large, the skill definitions were extensive, and it was ingesting design context and code simultaneously. The result: the context window inflated rapidly and eventually hit a cryptic error.

The fix was to explicitly instruct it to use subagents for these tasks. It can automatically decide to do this, but it wasn’t doing it reliably. The main orchestrator agent could then delegate work to a fresh window, keeping context sizes under control, improving speed and cost, and allowing the system to run autonomously for much longer.

A Critical Failure: Design Drift

Even with good tooling, the agent failed early in an important way.

Its first implementation barely resembled the design. The core layout, content, spacing, and typography were present but wrong. This happened when the agent stopped using the predefined skills and diverged into its own implementation style.

I had explicitly instructed it to stop and ask if unsure. Instead, it pushed forward confidently.

At a pre-requested checkpoint, I intervened and instructed it to re-implement the page using the existing Tailwind references, the available skills, and design constraints from the brief.

The difference was stark.

This moment matters. Agentic AI does not yet reliably self-police against drifting away from intent unless constraints are actively reinforced.

What Agentic AI Is Good At

When it followed the defined skills and constraints, the agent performed well:

• Set up Next.js with solid conventions

• Translated Figma layers into React components

• Applied brand-compliant Tailwind tokens

• Wired Storyblok content into pages

• Raised, reviewed, and merged pull requests

• Deployed to Vercel and validated routes

At first, the output looked reasonable. For non-technical stakeholders, this would likely pass as “done” delivered extremely fast.

Where Judgment Still Breaks Down

The problems appeared where taste, quality, or risk awareness mattered:

• CMS fields were duplicated and poorly standardised

• Design tokens were bypassed with one-off hex values

• Architectural decisions optimised for speed, not longevity

• When auth tokens failed, the agent skipped CMS setup instead of asking

• A .env file was committed to GitHub, representing a serious security risk

Nothing was obviously broken. But much of it was fragile.

This is where senior engineering shows up: spotting future maintenance pain, understanding security risk, and knowing when “working” isn’t good enough.

So… Can AI Take My Job?

Not in the way the question is usually asked.

Agentic AI can already:

• Handle large amounts of boilerplate

• Compress weeks of setup into hours

• Raise, review, and merge code

• Act like a very fast, very confident junior engineer

It can’t yet:

• Own long-term quality

• Be trusted with security by default

• Understand organisational trade-offs

• Balance future flexibility against short-term speed

• Be accountable when things go wrong

The real shift isn’t replacement. It’s re-allocation.

Engineering work is slowly moving from writing code to:

·      defining skills and templates

·      designing constraints

·      reviewing outcomes

·      directing autonomous systems

With enough investment in agent skills and briefs, output quality improves dramatically. Over time, engineers will care less about low-level implementation details, and more about security, quality of output, and impact.

Agentic AI isn't ready to do software engineering on its own, but it is ready to change where engineers spend their time. At MSQ DX, we believe in Collective Intelligence: smart people solving complex challenges together. That now includes knowing how to orchestrate AI as part of that collective, combining human judgment with machine speed to ship better work, faster.