The Limits of Autocomplete

Three months with any tool is enough to stop being impressed by what it does well and start noticing what it cannot do. Copilot had earned its place in my workflow by that point. But the shape of its limitations was becoming clearer, and those limitations pointed at a problem that inline autocomplete was never going to solve.

The gap is not a bug. It's architectural. Understanding it changes how you use the tool.

The Pattern Ceiling

Copilot is trained on code. A lot of code. That training gives it strong pattern recognition for things the programming community writes repeatedly: HTTP clients, database connections, data transformation loops, test fixtures, configuration parsers. When your code looks like code other people have written, Copilot performs well.

The problem is that valuable engineering work often doesn't look like code other people have written. It looks like your specific domain, your specific conventions, your client's specific data model with its specific quirks. Copilot has never seen your fiscal calendar definition. It has no idea that this particular source system sends timestamps in Unix epoch milliseconds except for records created before 2019, which are in ISO 8601 with a non-standard timezone offset. It can't infer that from your function signature.

When I hit these domain-specific cases, Copilot would generate code that was structurally plausible and semantically wrong. Worse, it would do so confidently. The suggestions looked like solutions. They compiled. They would fail at runtime on the specific input cases that made this problem hard in the first place.

The Context-Switch Tax

The workflow I fell into: Copilot for structural scaffolding, ChatGPT for reasoning about the domain problem. Switch to the browser, brief the model on the problem, iterate on the logic, get a solution, come back to the IDE and implement it with Copilot assisting on the boilerplate.

This works, but it has a cost that's easy to underestimate. Context switching is not free. Every time you leave the IDE for a chat window, you break the flow state. And every time you open ChatGPT, you start from zero — re-explaining your project, your constraints, your conventions, your problem history. The model knows nothing about what you were just doing.

I tracked this informally for a few weeks. The average time spent re-establishing context at the start of a ChatGPT session was five to ten minutes. On a day where I needed three or four reasoning sessions, that's thirty minutes of re-briefing. Thirty minutes that produced no code, only put the model back at the starting line I'd already crossed.

That's the stateless problem. Not unique to Copilot — it's a property of all current LLM interactions — but it felt particularly sharp in contrast with what Copilot was doing right. Copilot had context. Chat had none.

What "Context" Actually Means Here

When I say Copilot has context, I mean it reads the files open in your editor. When I say ChatGPT has none, I mean it starts each session empty. These are different kinds of context, and conflating them is where the confusion starts.

What neither tool had was project memory: the accumulated facts about a system that a human engineer carries in their head after working on it for months. The knowledge that the accounts table has a soft-delete column that's never populated correctly, so you filter on deleted_at IS NULL using the audit log instead. The knowledge that the ETL team agreed last quarter to always land raw data before any transformation, even for simple field renames. The knowledge that the client's data retention policy requires a specific partitioning scheme that's not obvious from the table name.

None of that lives in the code in a form that an AI tool can read and apply. It lives in heads, Confluence pages, Slack threads, and tickets nobody updates after the decision is made. Getting a model to help you with domain-specific reasoning requires either re-explaining this context every session or finding a way to surface it automatically.

The Markdown Workaround Gets More Elaborate

My convention file started to grow. What had begun as a naming and structure reference expanded into something closer to a project brief: domain vocabulary, data model quirks, non-obvious business rules, known gotchas, decisions that had been made and why.

# Project: CRM Ingestion Pipeline
# Last Updated: 2024-03

## Domain Notes
- Accounts: soft-delete via audit log, NOT deleted_at column (always null)
- Fiscal year: starts October 1, not January 1
- ContactStatus enum: 0=active, 1=inactive, 2=merged (2 redirects to master_id)

## Agreed Patterns
- Raw landing always precedes transformation, even for trivial renames
- Timestamps stored as UTC, converted at presentation layer only

## Known Gotchas
- Source API rate-limits at 200 req/min, not 1000 as documented
- The orders.total_amount field is pre-tax in v1 records, post-tax in v2

Pasting this into every ChatGPT session reduced the re-briefing tax. It didn't eliminate it — I still had to paste it, wait for the model to acknowledge it, and trust that it was weighting it appropriately. And maintaining the document was becoming a task in itself. Every new gotcha I discovered needed to be added. Every decision that got revisited needed to be updated.

I was manually managing what should be a system problem.

The Question Starting to Take Shape

By the end of the third month, the question had moved from "how do I get the most out of Copilot?" to something broader: "what would it look like if an AI tool could carry project context across sessions, automatically, without me managing it by hand?"

That's a different problem than autocomplete. It's a memory problem. And the solution — whatever it turned out to be — was not going to come from the IDE extension market. It was going to require building something.

I wasn't there yet. But I was starting to see the shape of where this was headed. If you've hit the same ceiling — the point where Copilot is great at the pattern layer but leaves you stranded on domain knowledge — I'd genuinely like to hear how you're handling it. As always, I'm here to help.