GLM-5 Signals the Agentic Code Era: Why SDD Matters Even More

Intro

A hot argument is spreading across developer communities:

If Claude Code has plan mode and team swarm mode (with a PM agent generating PRDs), do we still need SDD? Do open-spec, spec-kit, and workflow still matter?

This question goes straight to the core engineering debate of 2026.

On one side, Claude Opus 4.6 Agent Teams reportedly used 16 instances to collaboratively build a C compiler capable of compiling the Linux kernel (100k lines), for around $20,000.

On the other side, Zhipu’s GLM-5 also clearly states: 2026 is the year of Agentic Code.

If AI can generate three months of code in one day, do we still need formal specs?

The answer is counterintuitive: in the Agentic era, SDD is not outdated. It is more important than ever.

1. Clarify the nature of the three concepts

1) What is plan mode?

At its core:

Structured reasoning output for the current task

Key properties:

ephemeral: discarded after use
current-context focused: solves immediate problems
no cross-task consistency guarantee
no long-term engineering contract

Plan is an agent’s reasoning draft, not an engineering asset.

2) What is swarm mode?

At its core:

A multi-agent collaboration framework

It looks like a full team:

PM agent writes requirements
Architect agent designs
Dev agent codes
QA agent tests

But note: swarm mode solves division of labor, not long-term governance standards.

Each run is task-driven and does not automatically ensure:

long-term architecture consistency
unified design language
continuous API standard evolution
requirement version traceability

Unless you design those constraints separately.

3) Then what is SDD?

SDD (Spec Driven Development) is:

Turning requirements, design, and constraints into engineering contracts

It is not “just documentation”. It is:

structured
diffable
reviewable
verifiable
test-bindable
enforceable as hard constraints for agents

SDD is system memory plus behavioral boundaries.

2. One table to show the core difference

Dimension	Plan	Swarm Mode	SDD
Lifecycle	Single task	Single task	Long-lived
Goal	Reasoning	Collaboration	Constraints
Engineering asset	No	No	Yes
Version-manageable	No	No	Yes
Agent constraint strength	Weak	Medium	Strong
Fit for long-term systems	Medium	Medium	Strong

Core view:

Plan is cognition
Swarm is collaboration
SDD is governance

They solve different problems. This is not a replacement relationship.

3. Why SDD matters more in the Agentic era

Before vs now

Before:

humans coded slower
discussions took longer
errors surfaced slowly

Now:

agents code extremely fast
one day can produce three months of code
bad decisions amplify at exponential speed

Without spec constraints, systems drift.

That is Agentic chaos, and many teams in 2026 are already seeing it.

A realistic scenario

Imagine this:

Today your PM agent defines RESTful APIs, tomorrow it switches to GraphQL because context changed.

Yesterday the dev agent used TypeORM, today it changes to Prisma.

Every agent is making “smart” local decisions, but nobody knows what the system is becoming.

That is not collaboration. That is chaos.

4. When SDD is truly not necessary

Scenario 1: Solo, short-lived projects

single developer
short lifecycle
low concern for long-term maintenance

Plan + swarm is enough.

Scenario 2: MVP validation stage

If your goal is rapid trial-and-error, heavy SDD can slow you down.

Ship first, standardize later.

5. When SDD is mandatory

1) Long-lived products

evolving for more than 6 months
multiple features in parallel
version history matters

2) Multi-team collaboration

multiple PMs
multiple developers
multiple agent roles

3) Complex domains

finance
healthcare
security systems
infrastructure

Because these systems require:

traceability
auditability
rollback ability
verifiability

Plan mode alone cannot deliver this.

6. Advanced form: swarm running under SDD constraints

Mature teams do not do “swarm replaces SDD”.

They do this:

Run swarms under SDD constraints

In practice:

PM agents must output using spec templates
Architect agents must follow interface standards
Dev agents can only code within spec boundaries
QA agents must generate tests from acceptance criteria

This is how you get stable systems.

7. The key decision question

Use one question to decide whether you need SDD:

Will this system still exist one year from now?

If yes, you almost certainly need SDD.

8. Final summary

2024: AI as a tool
2025: AI as a collaborator
2026: AI as an executor

Once AI becomes an executor, you need governance.

SDD is that governance structure.

Solo development

Plan + swarm -> enough

Small teams

Lightweight specs + plan + swarm -> best balance

Multi-team / long-lived products

Full SDD + swarm mode + workflow -> required

High-risk systems

SDD + swarm + strict audit -> survival strategy

Closing

The 2026 engineering paradigm is not a binary choice.

Plan, swarm, specs, workflow, and superpowers are not replacements for each other. They are controls at different layers.

The key is understanding each tool’s nature and combining them to fit your team.

Real engineering wisdom is not chasing whatever is newest. It is using the right tool for the right context.

欢迎关注公众号 FishTech Notes，一块交流使用心得！