Dealing with fairly complex features

[PeterDaumQS]

Hi,

we observe that on large / complex features everything went's smoothely until the implementation starts.

In the middle of the run, the LLMs start to halluzinate and loosing completely track + ignoring the plan / tasks / .. . We observe that everything goes south, when or closely before the compaction is triggered.

We understand that the context window running full is most likely the issue.

But what's the best strategy here?
Doing a spec of specs (eg let spec kit on the first iteration break down everything into smaller sub-specs) or let the implementation task focus only on a segment of tasks that may not overwhelm the model?

How do you approach these issues?

[mnriem]

Great question — context window exhaustion during implementation is a known challenge for any coding agent session

The implement command accepts free-form user input that the agent is required to honor before proceeding. This means you can scope each run without any tooling changes.

Option 1: Limit how many tasks run per invocation

Instead of letting implement run through all tasks at once, tell it to stop early:

/implement only execute tasks 1-10, then stop and report progress

or scope by phase:

/implement only execute the Setup phase, then stop

Since completed tasks are marked [X] in tasks.md, the next /implement invocation picks up where you left off. This keeps each run well within context limits.

Option 2: Instruct the agent to use sub-agents

If your coding agent supports sub-agents (e.g., Copilot CLI, VS Code Copilot), you can instruct implement to delegate individual tasks:

/implement delegate each parallel [P] task to a sub-agent

Each sub-agent gets a focused context (one task + relevant plan excerpts) rather than the full feature context, so compaction never triggers.

Option 3: Combine both

For very large features:

/implement execute only the Core phase, delegate [P] tasks to sub-agents

Which approach to choose

Approach	Best for
Limit to N tasks or a phase	Any agent; simplest; no sub-agent support needed
Sub-agent delegation	Agents that support sub-agents; maximizes parallelism
Decompose the feature into smaller specs	When even a single phase overwhelms the context

The "spec of specs" idea you mentioned maps to that third row — breaking the feature into independently spec'd sub-features, each with their own plan/tasks/implement cycle. That's a valid approach for truly massive features, but for most cases limiting task scope per run is the simplest fix.

[coders-kitchen]

Could we add this gem of knowledge to the documentation?

I assume addressing context exhaustion is a topic for many users, and worth a dedicated section / part of the documentation.

[mnriem]

Can you please file an issue for this and refer to this discussion? Thanks!