The IDE is a glorified notepad

Most codebase agents today are just fancy grep. You ask a question, it searches for strings, and it spits out a suggestion that breaks your build 40% of the time.

We’ve spent the last decade making editors faster. We moved from Eclipse to VS Code, and we replaced Java with TypeScript. But the mental model didn't change.

You still hold the entire dependency graph in your head. You still hunt through node_modules to figure out why a peer dependency is exploding.

The death of the file explorer

In two years, you won't care about your folder structure. Files are just a legacy storage mechanism for humans who can’t process more than 800 lines of code at a time.

If the AI knows the entire graph, why do you need to scroll through src/components/ui/internal/legacy/Buttons.tsx? You don't.

We are moving toward a world where UI is generated on demand. You’ll describe a state change, and the tool will rewrite thirty files across the stack.

The file explorer will become a debugger view. You’ll only open it when something goes horribly wrong.

Context is the only currency

LLMs are getting cheaper, but context is getting more expensive. Not in terms of tokens, but in terms of noise.

If you dump 100,000 lines of spaghetti into a context window, you get 100,000 lines of slightly more expensive spaghetti back.

The real engineering challenge isn't the model. It's the retrieval. At git11, we’re seeing that the best tools don't just 'read' your code.

They compute high-level signals: which functions are actually called, which tests cover which branches, and who touched auth.go last. This isn't just metadata; it's the map.

Your CI is about to get loud

GitHub Actions are currently a binary gate. They pass or they fail. This is a waste of compute.

Soon, CI will be an active participant. If a test fails, the CI shouldn't just send a Slack notification and wait for you to wake up.

It should open a PR against your PR. It should identify the regression in commit a8f21b, write a fix, and run the suite again.

If you’re still manually fixing lint errors in 2025, you’re doing it wrong. We should be spending our calories on architecture, not semicolon placement.

The repository as a database

We need to stop treating Git repos as a collection of text files. They are structured data.

Tools like tree-sitter were the start. The future is a persistent, queryable AST that lives in your dev environment.

You shouldn't 'find all references.' You should query for 'all callers of this function that don't handle the error return.'

When your tools understand the semantics, the 'AI' part becomes much easier. The model becomes a natural language interface for a very complex database of your intent.

Local vs. Cloud

Running models locally on a MacBook M3 is a hobby, not a strategy. You can't fit the knowledge of a 50k-file enterprise repo into a local context without losing your mind or your battery life.

The toolchain will split. Your editor will be a thin client. Your 'workspace' will be a massive, indexed, cloud-hosted instance of your entire company’s code history.

This isn't 'cloud-IDE' hype. It’s a physical necessity. The compute required to index and reason about code in real-time is too high for a laptop.

Technical debt is the new 'Out of Memory' error

We are about to hit a wall of AI-generated garbage. If it's easy to write code, people will write too much of it.

We already see this with PRs that are 2,000 lines longer than they need to be because an LLM hallucinated a helper library.

The next generation of tools won't just help you write code; they will be aggressive about deleting it.

We need 'Dead Code Detectors' that actually work. Not just 'this variable isn't used,' but 'this entire microservice hasn't been hit in six months and 90% of its logic is duplicated in the core API.'

Don't be a prompt engineer

If your job title is 'Prompt Engineer' in three years, you’re in trouble. That’s like calling yourself a 'SQL Formatter.'

The goal is to make the AI disappear into the background. It should be a ghost in the machine, fixing your typos and pre-fetching your documentation.

You should still know how to write a compiler. You should still know how a B-tree works. Because when the AI fails—and it will—you’re the only one left who knows how the 0s and 1s are moving.

Stop worrying about the AI taking your job. Start worrying about the guy who uses AI to do ten times more work than you, while spending half his day getting coffee.

Build things that scale. Delete code that doesn't. Stop treating your IDE like it’s 2014.