I use Claude Code and ChatGPT almost every day. They help me a lot, but with strict rules to prevent them from dumping junk code into the repo.

In Part 1 I talked about the general philosophy and which tasks I delegate or not. Here I dive into the day-to-day:

• The mental pattern I always follow
• How I use them for debugging
• How I use them for tests
• How I use them for architecture ideas
• How I give them context without handing over the repo
• A quick daily routine checklist

The idea isn’t for AI to program for you, but to take away what distracts you from thinking.

Base pattern: you think first, then AI complements

My mental pattern is simple:

1. You understand and reformulate the problem
2. You write your solution or at least your approach
3. Only then do you bring in AI to refine, question, or automate

1
flowchart LR
2
  P["Problem"] --> H1["Human thinks"]
3
  H1 --> Draft["Code draft"]
4
  Draft --> IA["AI suggests improvements"]
5
  IA --> H2["Human reviews and decides"]
6
  H2 --> Repo["Final code"]

Step 1: formulate the problem in your head

Before opening Claude or ChatGPT, I try to make my brain do the basic work:

• What exactly am I trying to solve?
• Where’s the difficult edge? (algorithms, API, performance, DX)
• What constrains the solution? (current stack, business constraints)

If you can’t explain it in 3 or 4 sentences, it’s not ready for AI yet. It’s a filter to prevent it from using you as a mental eraser.

Step 2: write your version first

Even if it’s pseudo-code, I always write something of my own before asking for help. Real example from my Hospeda project:

1
// Hook to filter destinations - I write it functionally first
2
export function useFilteredDestinations(
3
  destinations: Destination[],
4
  filters: DestinationFilters
5
) {
6
  return useMemo(() => {
7
    let result = destinations;
8

9
    if (filters.region) {
10
      result = result.filter((d) => d.region === filters.region);
11
    }
12

13
    if (filters.minRating != null) {
14
      result = result.filter((d) => d.rating >= filters.minRating);
15
    }
16

17
    if (filters.hasAccommodations) {
18
      result = result.filter((d) => d.accommodationCount > 0);
19
    }
20

21
    return result;
22
  }, [
23
    destinations,
24
    filters.region,
25
    filters.minRating,
26
    filters.hasAccommodations,
27
  ]);
28
}

Can it be improved? Sure. Does it work? Yes. I get it working first, then ask for help to polish it.

Step 3: AI as reviewer and alternative generator

Only here do I say something like:

1
This React hook works, but I want it:
2
- More readable
3
- Easier to extend if I add new filters
4
- Maintaining the same behavior
5

6
Propose 2 refactor alternatives, explaining pros and cons.

If it proposes something better, I compare. If it adds weird stuff, I discard it. The key: I don’t ask “how do I do this?”. I ask “how do you improve what already works?”.

Debugging: AI as a second pair of eyes

1
flowchart TD
2
  Bug[Weird bug] --> Repro[Reproduce the error]
3
  Repro --> Q1{Clear stack trace?}
4

5
  Q1 -- "Yes" --> Inspect[Inspect code]
6
  Q1 -- "No" --> IAContext[Give context to AI]
7

8
  Inspect --> Q2{Found the cause?}
9
  IAContext --> Hyp[AI proposes hypotheses]
10
  Hyp --> Q2
11

12
  Q2 -- "Yes" --> Fix[Apply the fix]
13
  Q2 -- "No" --> DeepDive[Deeper debugging]
14
  DeepDive --> IARefine[Return to AI with findings]
15
  IARefine --> Hyp
16

17
  Fix --> Tests[Run tests]
18
  Tests --> Done[Merge]

I use AI when:

• The error isn’t obvious
• The stack trace is cryptic
• You’ve already tried 2-3 things and you’re still stuck

Example debugging prompt

1
Context:
2
- Front: React 19 + TanStack Query
3
- API: Hono
4
- DB: Drizzle + PostgreSQL
5

6
Console error:
7
TypeError: Cannot read properties of undefined (reading 'items')
8

9
Component that crashes:
10

11
function DestinationsList() {
12
  const { data, isLoading } = useQuery({
13
    queryKey: ["destinations"],
14
    queryFn: () => destinationService.list({ page: 1, pageSize: 20 }),
15
  });
16

17
  if (isLoading) return <Spinner />;
18

19
  return (
20
    <ul>
21
      {data.items.map((d) => <li key={d.id}>{d.name}</li>)}
22
    </ul>
23
  );
24
}
25

26
What would you suspect and what things would you check step by step.
27
Don't invent new code, focus on possible causes.

AI doesn’t “magic” the bug away, but it organizes hypotheses, reminds you of edge cases you missed, and acts as a checklist when you’re already tired.

When the stack trace isn’t enough

I also use it to understand Drizzle or PostgreSQL errors:

1
I have this Drizzle error:
2

3
Error: Column "destinations.slug" must appear in the GROUP BY clause
4
or be used in an aggregate function
5

6
With this query:
7

8
const rows = await db
9
  .select({
10
    slug: destinations.slug,
11
    count: sql<number>`count(*)`.as("count"),
12
  })
13
  .from(destinations)
14
  .groupBy(destinations.region);
15

16
Explain to me:
17
1) What exactly is the error saying
18
2) Why does it happen with this query
19
3) Two correct ways to rewrite it

What I ask: that it explains. What I do: choose the solution and adapt it.

Tests: human intention, AI skeleton

1
flowchart TD
2
  Regla[Business rule] --> Coment[Write intention as comment]
3
  Coment --> Prompt[Prompt AI with the pattern]
4
  Prompt --> Skeleton[AI generates skeleton]
5
  Skeleton --> Review[Adjust mocks and asserts]
6
  Review --> RunTests[Run tests]
7
  RunTests --> Q{Passing?}
8
  Q -- "Yes" --> Commit[Commit]
9
  Q -- "No" --> Fix[Fix]
10
  Fix --> RunTests

For unit or integration tests:

1. I manually write the test intention
2. I leave it as a comment in the file
3. I ask AI to transform it into a test with my stack

Example comment:

1
// I want to test:
2
// - That DestinationService.list() returns paginated correctly
3
// - That it respects search filters
4
// - That if the actor doesn't have permissions, it returns FORBIDDEN

Typical prompt:

1
With this comment as a guide and using the test pattern from my project
2
(Vitest + factories), generate the complete tests.
3

4
Pattern I use:
5

6
import { beforeEach, describe, expect, it, vi } from 'vitest';
7
import { createActor } from '../../factories/actorFactory';
8
import { createModelMock } from '../../utils/modelMockFactory';
9

10
describe('DestinationService.list', () => {
11
  let service: DestinationService;
12
  let model: ReturnType<typeof createModelMock>;
13

14
  beforeEach(() => {
15
    model = createModelMock();
16
    service = new DestinationService({ logger: mockLogger }, model);
17
    vi.restoreAllMocks();
18
  });
19

20
  it('should return paginated list', async () => {
21
    // ...
22
  });
23
});

AI builds the skeleton. You adjust mocks, assertions, and edge cases you know from the business.

Example with simple function

Function to generate slugs:

1
export function generateSlug(name: string, existingSlugs: string[]): string {
2
  const base = name
3
    .toLowerCase()
4
    .normalize('NFD')
5
    .replace(/[\u0300-\u036f]/g, '')
6
    .replace(/[^a-z0-9]+/g, '-')
7
    .replace(/^-|-$/g, '');
8

9
  let slug = base;
10
  let counter = 1;
11

12
  while (existingSlugs.includes(slug)) {
13
    slug = `${base}-${counter}`;
14
    counter++;
15
  }
16

17
  return slug;
18
}

Prompt:

1
Generate tests with Vitest for this function, covering:
2
- Base case with simple name
3
- Name with accents and special characters
4
- Name that already exists (should add numeric suffix)
5
- Multiple collisions (should increment the counter)
6

7
Don't use weird magic values, keep it simple.

AI makes the draft, you keep the criteria.

Architecture: AI as an annoying colleague

When I’m deciding something about architecture, I use AI as that colleague who always has an opinion, sometimes says nonsense, but forces you to justify what you do.

Real example:

1
Project context:
2
- Monorepo with apps/web (Astro), apps/admin (TanStack Start), apps/api (Hono)
3
- packages: @repo/db (Drizzle), @repo/service-core, @repo/schemas (Zod)
4

5
I want to decide where the logic for "featured destinations" lives that:
6
- Reads accommodations from each destination
7
- Calculates a score based on reviews and bookings
8
- Returns a sorted list
9

10
Propose two options:
11
1) Custom method in DestinationService
12
2) Direct query in the route handler
13

14
In each case: advantages, disadvantages, impact on testing and reuse.

I don’t delegate the decision. I use it to see angles I might be missing.

Context without giving away the repo

Minimal but sufficient context

No need to paste 2000 lines of code. I prefer:

• 1 key file
• A short description of the architecture
• The relevant types

My rule:

• If the answer depends on a specific detail → paste relevant code
• If it’s a design question → describe, don’t paste

Example with real handler

1
export const destinationListRoute = createListRoute({
2
  method: 'get',
3
  path: '/',
4
  handler: async (ctx, _params, _body, query) => {
5
    const actor = getActorFromContext(ctx);
6
    const result = await destinationService.list(actor, query || {});
7

8
    if (result.error) throw result.error;
9

10
    return {
11
      items: result.data?.items || [],
12
      pagination: getPaginationResponse(result.data?.total || 0, query),
13
    };
14
  },
15
});

Prompt:

1
My service architecture:
2
- All extend BaseCrudService
3
- Each service has permission hooks and normalizers
4
- Call pattern: service.list(actor, filters)
5

6
With this handler, what refactors seem reasonable to:
7
- Handle the error more cleanly
8
- Avoid repeated optional chaining
9

10
Don't invent new services, work with what's there.

Limits I set no matter what

No credentials or sensitive data

In a rush you can make a mistake. Rules I set for myself:

• Never paste API tokens
• Never paste production secrets
• Never paste real connection strings
• Never paste real user data

Instead of the real connection string, I send: postgres://USER:PASS@HOST:PORT/DB_NAME and clarify it’s a placeholder.

No final business decisions

Things I don’t delegate:

• Pricing criteria
• Permission rules by role
• Legal or compliance things

AI can help me express it in code, but I define the rule.

Cases where it really saved me time

Big refactor without dying in diffs

I had to move all imports from @repo/db/schema/* to @repo/db without breaking anything in the monorepo.

Flow:

1. I asked Claude Code to detect old imports, replace them, and show me diffs per file
2. I reviewed each diff carefully

Work that would’ve been 3-4 hours by hand went to ~1 hour with human control.

Tests I was never going to write “out of laziness”

I had services with custom methods (getSummary, getStats, getFeatured) that I “knew” I had to test, but never got around to.

I used AI to generate the test skeleton following my pattern. I adjusted logic, names, and added edge cases.

Result: went from “someday” to “today”.

Cross bug debugging

Search filters weren’t being applied the same in the service and in the route handler.

I used AI to:

1. Map the filter flow: query params → handler → service.list() → model.findAll()
2. Build a debugging checklist

It organized my head more than the code. Just that alone saves you time.

Daily routine checklist

1. I understand it first — If you can’t explain it in 3 sentences, it’s not ready for AI
2. You write something of your own — Code draft, idea, test comment
3. AI complements, doesn’t create from scratch — Refactors, tests, docs, explanations
4. Always review diffs — Nothing enters the repo without passing through your eyes
5. Run tests — If you touch tested code, tests must pass
6. Be careful what you paste — No secrets, no real data
7. Don’t let it decide for you — Architecture, business, and security are your responsibility

Closing

Claude and ChatGPT can be part of your daily routine without turning your repo into a Frankenstein.

The key is in three things:

• Clear mental pattern: you think first, then AI helps
• Concrete flows: debugging, tests, refactors, and assisted (not outsourced) design
• Healthy boundaries: no secrets, no delegated business decisions, no blind commits

If you treat them as tools and not as oracles, they’re like having a hyper-fast junior next to you… but the senior who signs the commits is still you.

References

• Claude Code — Integrated assistant to work on the repo
• ChatGPT — For long text, examples, and guided debugging
• Part 1: AI as copilot, not as suicide pilot — The general philosophy
• Configuring Claude Code for large monorepos — Setup for complex projects