Most Developers Are Using AI Wrong

Most developers are using AI wrong.

They ask it to generate functions. They paste errors. They chase speed.

That's incremental gain — the same workflow with a faster autocomplete.

The real leverage comes from using Claude Code + Plan with Files as an architectural thinking engine. Context plus structured planning beats raw generation every time.

Originally published on LinkedIn. Part 1 of a series on practical AI coding workflows.

The core insight

When Claude reads your actual files, it stops guessing. It starts reasoning within constraints.

Instead of:

"Write this function."

I now ask:

• What dependencies does this change affect?
• Where is coupling too tight?
• What will break if we scale this 10x?
• What should be refactored before implementation?

Only after the plan is clear — I generate code.

This flips the workflow from output-driven to design-driven.

Why this matters for senior engineers

The ROI isn't faster typing. It's reduced architectural entropy.

AI increases local velocity. Without structured planning, that velocity produces:

• Silent coupling between modules
• Responsibilities that drift file by file
• Refactors that look small but mutate system boundaries

Senior engineers should pay attention because the bottleneck was never keystrokes. It was clarity under complexity.

AI is not replacing implementation. It's accelerating structured reasoning — if you give it structure to reason about.

How Plan with Files changes the loop

Claude Code's Plan mode with file context does three things traditional chat can't:

1. Grounds assumptions in real code — imports, interfaces, and call sites are visible, not inferred
2. Surfaces cross-file impact — a one-line change in PricingEngine may affect checkout, invoicing, and rev rec
3. Separates planning from execution — you review a plan before the model touches ten files

The discipline is simple: no code until the plan survives your scrutiny.

A practical workflow

1. Scope the change — one sentence: what problem, what boundary
2. Ask for a plan — dependencies, risks, files touched, test strategy
3. Challenge the plan — "What happens if usage arrives late?" "Where is this not idempotent?"
4. Approve and execute — generate in small, reviewable chunks
5. Verify — tests plus architectural check: did any file's responsibility drift?

This is slower per prompt. It's faster per merged PR that doesn't get reverted.

What this is not

This isn't anti-AI Luddism. Use AI for boilerplate, test scaffolding, and repetitive refactors — after the design is clear.

This isn't unlimited planning either. Time-box exploration. The goal is a decision, not a document.

What's next in this series

The follow-ups cover complementary workflows:

• Spec-driven vibe coding vs. Claude Code Plan Mode — when to optimize for speed vs. correctness
• An AI-native architecture control system — documentation as context governance
• Hands-on with Claude Code + Ralph Loop — iterative Plan → Generate → Reflect loops

Different problems need different cognitive modes. The leverage is knowing which mode you're in before you prompt.