I Replaced My IDE with a Terminal AI Agent for a Week – Lessons Learned

A personal experiment using Claude Code as the primary development environment. Honest about trade-offs.

Written by
Richard Batt
Published
17 February 2026
Reading time
8 minutes
Share on LinkedIn

Key takeaways

  • The Experiment, apply this before building anything.
  • Day 1: The Honeymoon Phase (This Actually Work).
  • Day 2: The Prototyping Sprint (Momentum!).
  • Day 3-4: The Wall (This Is Where It Gets Messy).
  • Day 5: Refactoring and Tests (Different Tools for Different Work).

The Experiment

Three weeks ago, I had a crazy thought. Everyone talks about AI being the future of programming, but I wasn’t actually testing that claim in a structured way. So I decided to run an experiment: for one week, I would do all my development work in Claude Code’s terminal agent mode. No VS Code. No jumping to my IDE. Pure terminal, pure Claude. I wanted to understand what actually works, what doesn’t, and where the real friction is.

I chose a realistic project: refactoring a client’s API layer from REST to GraphQL. Not a toy problem. Real code. Real trade-offs. Real pressure to get it right. Here’s what I learned, day by day.

Day 1: The Honeymoon Phase (This Actually Work)

I started Monday morning. The project is a Node.js API layer, about 8,000 lines of code spread across 30 files. I’d already done the architecture in my head-I knew what the result should look like. I just needed to execute it.

I opened Claude Code and started: I have a REST API at /app/api. It has these 30 endpoints. I need to convert this to GraphQL. Start by reading the current structure and proposing the new schema. Then I went to make coffee.

By the time I came back, Claude had:

  • Read all 30 files
  • Mapped the current REST endpoints to logical query/mutation groups
  • Proposed a GraphQL schema
  • Identified places where the old code had weird assumptions that would need to change

All of that in about 90 seconds. I would have spent an hour just reading and note-taking. That was the moment I thought: okay, this actually work.

We iterated on the schema together. I’d say this resolver should also return the user’s permissions and Claude would update the schema. We had a full GraphQL spec in about two hours of actual conversation time. The work that usually takes me a full day took us a morning. I was sold.

Day 2: The Prototyping Sprint (Momentum!)

Tuesday, we started building. The resolvers. The type definitions. The middleware. Claude generated scaffolding, I read it, we iterated. Things that would be tedious in an IDE-creating 40 similar resolver functions, pulling out common patterns-Claude did fast and consistently.

I didn’t have to leave the terminal. No switching contexts. No where am I in the codebase? Every new function appeared in the right file with the right imports already handled. I started to understand why people talk about agentic coding. You describe what you want in natural language. It appears. You ask clarifying questions. It adjusts.

By end of day Tuesday, we had working GraphQL resolvers handling 80% of the original endpoints. Still needed testing and edge cases, but the bulk of the work was done. That’s probably 3-4 days of IDE work compressed into a day and a half. The time savings were very real.

Day 3-4: The Wall (This Is Where It Gets Messy)

Wednesday morning, I tried to run the code. It crashed. Not surprising-we’d built fast, probably skipped some edge cases. But now I needed to debug. And that’s where things got hard.

The error was in a nested resolver, and it wasn’t immediately obvious which one. I had Claude search through the code, and we found the issue. But the debugging was slow. Here’s why: in VS Code, I can hover over something and see what type it is. I can jump to definitions instantly. I can see the full context of a function while looking at the call site. I can set a breakpoint and inspect the actual runtime value.

In the terminal, I was describing the problem to Claude, Claude was reading files and guessing at the issue, and we were going in circles. We’d fix one thing and hit another error three layers deeper. By end of day Wednesday, I’d spent six hours debugging what would have taken me 90 minutes in VS Code. The efficiency advantage completely disappeared.

That was humbling. I realized: writing code and debugging code are completely different tasks. The agent is great at the first. It’s okay at the second.

Day 5: Refactoring and Tests (Different Tools for Different Work)

Thursday, I switched gears. I asked Claude to write tests for the code. Then I asked it to refactor for consistency-pull out repeated patterns, improve naming, clean up the structure. This is where the terminal mode felt good again.

Writing tests is repetitive. Create a describe block. Create a few test cases. Check the same things each time. Claude did 40 test cases in probably 30 minutes. I’d have written 10 in that time. The tests were actually good-they caught a real bug in the pagination logic that neither of us had noticed.

Refactoring, too. I said we have 12 resolver functions that all do basically the same permission check at the start. Extract that into a shared middleware. Claude did it. I read the result. It was correct. We committed it. Fast and clean.

Day 6: Exploring Unfamiliar Code (The Hidden Win)

Here’s something I didn’t expect to be valuable: the agent is genuinely good at exploring unfamiliar code. Friday, we discovered that the new GraphQL layer needed to integrate with a legacy microservice I’d never touched. The code was a mess. 3,000 lines. Undocumented. No tests.

I said to Claude: We need to call the user-service API. Can you read the existing code and tell me how it works? Claude read it. Found the client library. Traced the actual API calls. Identified which endpoints we cared about. Proposed wrapper functions that would let us use it cleanly from the GraphQL layer. Did all of this in about 20 minutes of reading and thinking.

In an IDE, I’d probably do the same thing manually, but it would take longer and I’d probably miss something. Claude’s ability to just read a pile of unfamiliar code and extract meaning is legitimately valuable. I’m flagging this as a real win.

Day 7: The Reality Check

By Friday afternoon, we had a working GraphQL API. It handled the main use cases. Tests were mostly passing. Some edge cases remained, but nothing catastrophic. The code was reasonably clean.

But here’s the honest part: I wouldn’t ship this code without switching back to the IDE for a day. Why? Because there’s still uncertainty in my head. I can read code on the screen and convince myself it’s right. I haven’t actually debugged it in a live environment. And visual layout still matters-I look at a big file and think this is too long, should split it when I can see it all at once. Reading a 500-line file description doesn’t give me the same mental model.

So Friday, I fired up VS Code. I opened the codebase. I read through the architecture. I manually tested a few paths. And within 30 minutes, I’d caught two actual bugs that the tests didn’t cover. Small ones, but real.

What Actually Worked Well

Let me be clear about where the agent excelled:

Rapid prototyping: When you have a clear direction and you need to move fast, Claude is faster than typing. The velocity advantage is real.

Refactoring: Pulling out patterns, renaming things, reorganizing code. Claude is fast and consistent. It finds patterns you’d miss.

Writing tests: Repetitive test cases are boring for humans. Claude doesn’t get bored. Creates complete coverage quickly.

Exploring unfamiliar codebases: Reading new code and extracting meaning. Claude can do this without the fatigue a human developer feels.

Thinking in natural language: Instead of I’ll add an async/await here, you just say this needs to be async, can you fix it? That’s actually easier. Your brain works more in problem-space, less in syntax-space.

Commit messages: Claude generates great commit messages. Clear, concise, explains the why not just the what. This alone saved me time-I stopped writing them myself.

Where It Really Struggles

Visual debugging: You can’t see the code while looking at the stack trace. You can’t hover over something and see its type. Debugging in the terminal is slower because you’re reconstructing the context manually.

Large file navigation: An IDE lets you split the screen or have multiple files open. You can see the caller and the callee side by side. In the terminal, you’re asking Claude to hold both in memory, and sometimes it forgets context.

Visual design: If any of your code does visual stuff-layouts, styling, responsive behavior-you need to see it. Reading CSS descriptions doesn’t tell you if it looks right.

Complex state: For code with intricate state management or weird edge cases, the uncertainty is higher. The agent miss something. You need to verify manually.

What I Actually Kept Doing

Here’s the honest verdict: I’m not replacing my IDE. But I’m using Claude differently now.

For new projects and clear refactoring work, I’m doing more in the terminal. It’s genuinely faster. The velocity is better. I save probably 30-40% of development time on tasks where there’s a clear structure and no major surprises.

For debugging, integrating with existing systems, and anything with visual output, I’m back in the IDE. The feedback loop is just faster. I can see what’s happening.

And I’m definitely using Claude for exploration. When I’m learning a new codebase, Claude is my pair programmer. It reads things, I ask questions, we both understand the code faster than I would alone.

The Interesting Pattern

The real insight from this week: programming isn’t one skill. It’s at least three. Writing new code. Debugging existing code. Understanding unfamiliar code. The AI agent is asymmetrically good at these. Great at writing. Okay at understanding. Frustrating at debugging.

That’s useful information. It means the future of development isn’t AI replaces the IDE. It’s AI handles the parts where it’s fast, you handle the parts where you need to see and feel. And your job changes from typing code to orchestrating the agent, reviewing output, and doing the parts that require intuition.

That’s actually interesting work. More thinking, less mechanical. I could get used to that.

Tagged: AI Tools, Development

Richard Batt
Richard Batt

I build automations, AI steps and custom software for businesses with 5 to 200 staff. 120+ projects across 15+ industries, from Middlesbrough.

About meSee the work

More on software and development

All writing

Need a workflow built? Tell me what is slowing your team down.

One paragraph is enough. I reply personally.

Bring me your worst workflow