Hot take: Claw Code's context window limit cripples it for legacy codebases

Alright, folks, I need to vent and get some collective wisdom on this. I've been integrating Claw Code's AI completion into my daily Kubernetes YAML/Helm/Terraform authoring workflow, and I've hit a wall that feels fundamental.

My primary issue: the hard context window limit seems to completely fall apart when you point it at a *real* legacy Helm chart or a sprawling Terraform module. We're not talking about a few hundred lines. I'm working with some in-house Helm charts that have evolved over 4 years. The `templates/` directory alone can have 30+ files, and the `values.yaml` is a beast with nested configurations for 10+ microservices. When I ask Claw Code to, say, "add a new sidecar container to the backend deployment with these specific volume mounts and environment variables," it often fails to grasp the full structure because it can't ingest the relevant `_helpers.tpl`, the existing deployment.yaml, **and** the relevant subsection of `values.yaml` all at once.

The result? It hallucinates template functions, invents non-existent values paths, or gives me a syntactically correct snippet that breaks the chart's established patterns. It's like having a brilliant engineer who only reads every third page of the specification. 😩

Here's a concrete example from a recent struggle. I needed to modify an Istio `VirtualService` template within a chart. The context required:

* The existing `virtualservice.yaml` template (45 lines)
* The related `deployment.yaml` for service naming context (60 lines)
* The `values.yaml` section defining Istio ingress hosts (deeply nested, ~50 lines)
* A key macro from `_helpers.tpl` (25 lines)

That's easily 180+ lines of critical, inter-referential YAML and templating code. Claw Code, working with just the open file, produced a guess that was wrong. When I tried to provide more files via the chat, it clearly hit a limit and started ignoring earlier parts of the conversation.

Has anyone else run into this with large config/codebases? I'm wondering:

* Are there specific strategies to chunk your queries or pre-feed context that works?
* Does using the "project" or repository-level context scanning feature actually help for these deep, logical dependencies, or does it just add more noise?
* Have you found certain file organizations or documentation styles that make these tools cope better?

My fear is that the very projects that would benefit most from AI assistance—the large, mature, complex codebases—are the ones currently crippled by this architectural constraint. It forces you back to meticulous, manual tracing of values and templates, which is exactly what I hoped to accelerate.

For reference, my typical plugin list for this work:
- Claw Code
- YAML Language Server
- Terraform LS
- Helm Intellisense
- GitLens

Kubernetes v1.28, local dev on macOS, using Neovim with a heavily customized LSP setup. The memory/performance is fine; it's the *context starvation* that's killing me.