The Advantages of Combining Sub Mode with Waterfall and Agile

Sub mode addresses "how multiple sub-agents divide the work and collaborate." Waterfall and Agile address "how the task moves forward and gets delivered."

First, a clarification: in Heicode's one-click "Dev Mode Team" deployment feature, Waterfall and Agile each correspond to a fixed role template — Agile = Product (planner) + Dev (executor) + Review (code-reviewer), 3 roles total; Waterfall = Analysis (analyst) + Architecture (architect) + Dev (executor) + QA (qa-tester) + Review (code-reviewer), 5 roles total — both the roles and the headcount are fixed. What this article discusses is combining Sub mode (freely assembled sub-agents) with the delivery cadence of Waterfall/Agile — this is a usage pattern outside the fixed templates, where you assemble your own Sub team and drive it at a Waterfall or Agile cadence; it does not mean the fixed one-click template itself can freely add or remove roles.

So Sub mode isn't a replacement for Waterfall or Agile. The more accurate way to understand it:

• Waterfall defines the stages and acceptance.
• Agile defines the iterations and feedback.
• Sub mode boosts the execution capability within each stage or each iteration.

Why combine Sub mode with the delivery process

Traditional Waterfall and Agile usually rely on people to divide the work, execute, test, review, and put together the deliverables. With Sub mode introduced, a single task can invoke multiple sub-agents at once, letting different roles handle local problems in parallel.

This brings three changes:

• Complex tasks no longer fall entirely on one Agent.
• Execution, review, testing, and deployment can be separated.
• Every stage or iteration can build a more complete chain of evidence.

Sub plus Waterfall

Waterfall mode emphasizes stage order and formal acceptance. It's a good fit for high-risk, strongly regulated tasks that need an audit trail.

Layering Sub mode onto Waterfall boosts the processing efficiency and quality within each stage.

How it works

Requirements confirmation
-> Sub: the Product Agent organizes scope, the Reviewer Agent checks for ambiguity
-> Design
-> Sub: the Architect Agent designs the approach, the Reviewer Agent checks risk, the Ops Agent checks deployment impact
-> Implementation
-> Sub: Frontend / Backend divide the work, implement, and self-test
-> Testing and review
-> Sub: the Reviewer Agent runs verification and reviews the diff
-> Release approval
-> The Ops Agent prepares the deployment, executed after human approval

Main advantages

Good-fit scenarios

• Production deployment.
• Legal and privacy clause releases.
• Security remediation.
• Data migration.
• Formal customer delivery.
• Main-branch merges and version releases.

Control focus

• Stages cannot be skipped automatically.
• High-risk operations must be approved.
• Every sub-agent only gets the permissions needed for the current stage.
• Reviewer and execution roles must be kept separate.
• A rollback plan is required before release.
• Every stage must leave behind an audit record.

Sub plus Agile

Agile mode emphasizes small-step iteration and continuous feedback. It's a good fit for tasks whose requirements will change and that need fast validation.

Layering Sub mode onto Agile boosts the parallel capability within each iteration.

How it works

Iteration 1: define the MVP
-> Sub: the Product Agent organizes this round's scope
-> Sub: Frontend / Backend divide the work and implement
-> Sub: the Reviewer Agent reviews the results
-> Accept this round

Iteration 2: add more features
-> Sub: keep splitting the work according to this round's goal
-> Accept this round

Iteration 3: polish the experience and prepare for launch
-> Sub: UI, testing, documentation, and Ops divide the work
-> Prepare to switch to a Waterfall release

Main advantages

Good-fit scenarios

• MVP development.
• Product feature iteration.
• UI and interaction optimization.
• Doc sites, resource centers, help centers.
• Tasks needing continuous feedback from a customer or team.
• Exploratory feature validation.

Control focus

• Keep 1 to 3 main goals per round.
• New requirements from this round go into the next round.
• Every round needs an acceptable deliverable.
• Budget is set separately per round.
• If direction changes significantly over several consecutive rounds, re-confirm the goal.
• Switch to the formal Waterfall release process when preparing for official launch.

Combining Sub with both Waterfall and Agile

Real projects often need both Agile and Waterfall at the same time.

A common approach:

Agile stage: quickly build an MVP and iterate over multiple rounds
-> Use Sub mode internally in each round to divide the work
-> Once features stabilize, move into the Waterfall stage
-> Continue using Sub mode within the Waterfall stage for review, testing, and deployment prep
-> Release after human approval

The benefits of this combination:

• Agile gives you speed and feedback early on.
• Sub boosts parallel execution capability in the middle.
• Waterfall controls release risk later on.
• Permissions, budget, approval, and audit are preserved throughout.

The relationship with Swarm mode

Sub combined with Waterfall or Agile is still controlled collaboration, not a full Swarm.

Its advantages are:

• Easy to explain to customers.
• Easy to set permission boundaries.
• Easy to control budget.
• Easy to audit.
• Well suited to formal delivery right now.

Swarm mode is a good fit for exploratory tasks that need multiple workers processing in parallel: on a tenant virtual machine, a lead Agent breaks down the task and dispatches it to up to 8 (3 by default) worker Agents for parallel execution. Move into Swarm mode when the task needs this kind of parallel exploration capability.

You can think of it this way:

Sub + Agile: fast iteration
Sub + Waterfall: formal delivery
Swarm mode: complex, dynamic collaboration

Summary

Sub mode itself provides multi-Agent division of labor.

Combined with Waterfall, it makes formal delivery more efficient, more reviewable, and more controllable.

Combined with Agile, it makes every iteration faster, more complete, and easier to keep gathering feedback on.

In the end, Heicode can form one complete path:

Agile exploration
-> Sub division of labor and execution
-> Waterfall release
-> Swarm for more complex, dynamic collaboration