Ethan Mollick, Associate Professor at The Wharton School and author of Co-Intelligence, recently shared something that caught my attention: "There's been a huge, obvious leap by agentic AI in the past six weeks that even early adopters are just catching up to." He added that the change is so large he is reconsidering whether last year's AI projects are still worth doing.

That hit because it captures a feeling many teams have right now: the ground is moving under our roadmaps. What looked ambitious three months ago can feel strangely small today, while tasks we assumed required a multi-quarter build can suddenly be delegated to an agentic system.

In his post, Ethan offered a blunt triage that I keep coming back to. Most AI projects, he suggests, fall into new categories:

"stuff I should do quickly before it becomes obsolete"
"stuff not worth doing anymore"
"stuff I should just let Claude Code do"

This blog post is my attempt to expand on that idea as a practical strategy. If agentic AI has really taken a leap, then the winning move is not to do more AI projects. It is to re-prioritize the right ones, faster.

What changed: from tools to agents

A lot of AI adoption over the last year looked like "AI as a feature" or "AI as a helper". You wrote prompts. You got drafts. You copied outputs into workflows. Value came from content generation, summarization, and lightweight automation.

Agentic AI changes the operating model. Instead of single responses, you can assign a goal and let the system plan steps, call tools, write and run code, iterate, and report back. That is the leap Ethan is pointing at: more autonomy, more integration, and better reliability in completing multi-step work.

The practical consequence is uncomfortable: projects that were worth building to compensate for tool limitations may no longer be worth building at all.

Key insight: when capability jumps, the project portfolio needs to be re-scored, not just accelerated.

Ethan Mollick's 3-bucket triage, expanded

Let me take each bucket and turn it into a clear decision rule you can apply to your backlog.

1) "Do quickly before it becomes obsolete"

These are projects where the window is closing, but there is still real value if you move now. Typically they share one of these traits:

They produce a durable asset (clean data, labeled examples, a governed knowledge base).
They embed into process change (training, policy, workflow redesign) that will still matter even if models improve.
They are tied to a time-bound advantage (a seasonal campaign, a product launch, a contract renewal).

Examples:

Creating a high-quality evaluation set for your domain (support tickets, policy exceptions, quality rubrics). Better models still need your definition of "good".
Fixing information architecture and permissions so agents can safely access the right files. Capability without access is wasted.
Shipping a narrow customer-facing use case with strong guardrails (for example: refund eligibility explanation with citations), before competitors catch up.

Decision test: If a more capable agent arrives in 8 weeks, does this work still provide compounding value? If yes, do it now.

2) "Not worth doing anymore"

This bucket is the hardest emotionally because it implies sunk cost. These are projects built to bridge a gap that has largely disappeared, or projects where the maintenance burden will exceed the benefit.

Common warning signs:

You are building a large prompt library, template system, or internal "prompt portal" that mainly compensates for weak model reasoning.
You are investing heavily in brittle glue code to chain multiple LLM calls, because the system cannot hold context or plan steps.
The project is "AI flavored" but not attached to a measurable business constraint (cycle time, cost, risk, conversion).

Examples:

A complex internal content generation workflow that exists because nobody trusts the model to follow instructions. If agents can self-check and iterate, your workflow can simplify dramatically.
A bespoke "AI coordinator" service whose primary job is to schedule tool calls and manage state. Many agent frameworks now bundle this.

Decision test: If a strong off-the-shelf agent can do 70 percent of this next quarter, are you still building a product, or just recreating commodity infrastructure?

3) "Just let Claude Code do"

Ethan's third bucket is the most immediately actionable, especially for software teams. Some work is still valuable, but the right approach is to delegate big chunks to an agentic coding assistant rather than staff it traditionally.

This is not "replace engineers". It is "change how engineering time is spent".

Good candidates:

Refactors with clear acceptance criteria.
Test creation (unit tests, integration test scaffolding, edge case enumeration).
Migrations where the patterns are known (API version bumps, linting, formatting, framework upgrades).
Internal tools and scripts that are valuable but have been perpetually deprioritized.

What changes operationally:

Engineers shift from typing to specifying, reviewing, and integrating.
Code review becomes more like verifying a contractor's work: check assumptions, security, data handling, error cases.
The bottleneck moves to product clarity and domain constraints, not implementation speed.

Decision test: Is this task primarily "translation" from intent to code? If yes, let an agent do the first 80 percent.

A simple portfolio re-score for the next 30 days

If the last six weeks changed the landscape, you need a fast, repeatable way to decide what stays on the roadmap.

Here is a lightweight scoring model I use when I want to avoid endless debate.

Step 1: Score each project on four dimensions (1-5)

Durability: will this still matter as models improve?
Differentiation: does it create advantage, or is it commodity?
Delegatability: can an agent complete most of the work with oversight?
Risk: what is the downside if it goes wrong (security, compliance, customer trust)?

Interpretation:

High durability + high differentiation: keep, and fund properly.
Low durability + low differentiation: kill or pause.
High delegatability: keep, but change staffing and timeline assumptions.
High risk: keep only if you can add guardrails, monitoring, and human-in-the-loop checks.

Step 2: Convert the score into Ethan's buckets

Bucket 1 (do now): durability is high and timing matters.
Bucket 2 (not worth it): differentiation is low and durability is low.
Bucket 3 (delegate): delegatability is high and risk is manageable.

Step 3: Redefine "done" for an agentic era

One reason projects drift is that teams define success as "we built the thing". In an agentic environment, "done" looks more like:

Documented objective and constraints.
Measurable evals (accuracy, latency, cost, refusal rate, hallucination rate).
Access controls and audit logs.
Monitoring and rollback.
A clear escalation path to humans.

In other words, the moat is not the model call. It is the system around it.

What leaders should do differently this quarter

Ethan Mollick's post reads like a warning: your 2025 assumptions may be stale. Here are the behavior changes I would adopt immediately.

Cut planning cycles in half

If capability leaps can happen in weeks, quarterly plans need mid-quarter revalidation. Set a recurring "capability review" where teams demonstrate what agents can now do end-to-end.

Treat agents as junior operators, not magic

Agentic AI can be stunning, but it still needs:

Clear goals and stopping rules.
Guardrails around data access.
Verification steps.
Human sign-off where the cost of error is high.

Invest in the unglamorous foundations

The most durable work is often boring: data hygiene, permissions, evaluation harnesses, and workflow design. These are exactly the items that stay valuable even as models leap.

Another key insight: model progress commoditizes features, but it increases the payoff to great systems, constraints, and measurement.

Bringing it back to Ethan Mollick's point

When Ethan Mollick says the leap is big enough that he is reconsidering last year's AI projects, I hear a call to be ruthless and practical. Not pessimistic, not hype-driven, just honest about what changed.

The teams that win are the ones that:

Ship durable infrastructure quickly.
Stop building commodity scaffolding.
Delegate implementation aggressively while tightening verification.

If you take only one action from this: pick five active AI initiatives and force-rank them into Ethan's three buckets this week. The clarity you gain is worth more than another month of incremental building.

This blog post expands on a viral LinkedIn post by Ethan Mollick, Associate Professor at The Wharton School. Author of Co-Intelligence. View the original LinkedIn post →