After a year of daily AI tooling on real projects, the pattern is clear: the engineers who ship faster aren’t the ones who use the most AI — they’re the ones with strict verification habits and good scope discipline. This post is the working set of habits.

The habits that compound

1. Read every diff

The agent wrote 200 lines. Read all 200. Even when you trust the agent, even when it looks right. Especially in unfamiliar code.

You’re the responsible engineer. Not “I just clicked accept.”

2. Run the tests

Before merging an AI-written PR: tests pass, type checker passes, linter passes. Bake this into CI (CI/CD Best Practices ).

3. Tight scope

“Implement the new checkout flow” is a recipe for an off-the-rails 500-line PR you can’t review.

“Add a validate_address function with these signatures” is reviewable. Same for the agent. Same for you.

4. Multi-session for hard problems

Spec → Implement → Review. Three sessions, fresh context each. Catches bugs single-session misses. See Claude Code Skills and Agentic Coding Patterns .

5. Iterative, not one-shot

Don’t “give the agent the whole feature.” Give it the next concrete step. Each step verifiable.

6. Commit often

Each working step is a git commit. When the agent goes off the rails, git reset --hard HEAD~3 is your friend. Without small commits, you’re stuck untangling.

7. CLAUDE.md / Cursor Rules

Project-level rules pay back forever. The agent stops doing the wrong thing because you told it once.

8. Keep your fundamentals

The biggest mistake: stop learning. AI as a crutch, not an amplifier. The senior engineers I see thriving in 2026 still read papers, still understand their stack, still verify by reasoning.

The anti-patterns

“Vibe coding”

Letting the agent write whatever, accepting whatever, hoping it works. This is how you ship security holes.

Agent for everything

Some tasks are faster typed. A two-line CSS fix doesn’t need a multi-step agent.

One giant session

Long sessions accumulate context drift. The agent forgets what was decided 80 messages ago. Use multiple sessions.

Skipping understanding

“I don’t understand what this does but the agent says it works.” That’s a bug waiting.

No tests

The agent’s output passes only if your tests pass. Without tests, the agent’s output is “looks right.” That’s not enough.

Pattern by task type

Boilerplate

Agent writes; quick read; commit. Fast.

Refactor

Spec the change clearly. Agent does the multi-file work. You review the diff. Big productivity wins here. See Cursor vs Windsurf vs Claude Code .

Bug investigation

Agent narrows; you decide. Agents are good at “search for X”, less good at “diagnose this novel issue.”

New feature in unfamiliar area

Read the area first. Then small steps with the agent. Don’t shortcut understanding.

Production hot path

Especially for code you’ll deploy at scale: deeply review. The agent’s “looks right” output sometimes hides perf issues, race conditions, or subtle correctness bugs.

Cultural shifts

Teams that win with AI tools change how they work:

  • Code review weight changes. It’s not “did I write this right?” but “did the agent and I together produce something correct?”
  • PR descriptions matter more. Explain why, not what.
  • Tests matter more. They’re the ground truth.
  • Pairing patterns differ. Agent + human is one mode; human + human still matters.

On juniors

Special note: junior engineers who use AI as a crutch often plateau. They ship faster than peers initially, but their understanding doesn’t keep pace, and at the senior level it shows.

Advice for juniors: use AI to accelerate learning, not replace it. When the agent generates code you don’t understand, study it before merging. Slower in the short term; far faster in the long term.

What I do day-to-day

  • Two AI tools open: Cursor in IDE, Claude Code in terminal.
  • Skills for recurring tasks: release notes, db migrations, code review.
  • CLAUDE.md per project: conventions, gotchas, where things live.
  • One agent session per task, multi-session for hard ones.
  • Read every diff. Run tests. Commit often.
  • No autonomous overnight loops. I trust agents enough to write code; not enough to ship while I sleep.

Read this next

If you want my dotfiles + skills repo, it’s at rajpoot.dev .

Building something AI-, backend-, or data-heavy and want a second pair of eyes? I do consulting and freelance work — see my projects and ways to reach me at rajpoot.dev .