---
title: 'Interview me, or don''t stop: your agent''s memory sets how much it asks'
description: Tell your agent once how you like to be asked, and it keeps to it. Claude Code and Codex built one feature three ways, from an interview to almost no questions.
url: https://hamloy.com/blog/interview-me-or-dont-stop
---

[Blog](https://hamloy.com/blog)

# Interview me, or don't stop: your agent's memory sets how much it asks

Tell your agent once how you like to be asked, and it keeps to it. Claude Code and Codex built one feature three ways, from an interview to almost no questions.

14 October 2026 · Rahmakyan

Some days you want to make every call yourself: what the booking form asks, how big the deposit is, which service sends the email. Other days you want the agent to get on with it and leave you the two things that cost money. Hamloy doesn't pick one for you. The rules it gives every agent say what a question is: one of your decisions, with the options and the one the agent recommends. How many of them come to you is up to the agent, and the agent goes by what it remembers about you.

So you tell it once. Claude Code keeps what you tell it in its memory for that project. Codex reads your own instructions from your settings. Both are yours, not the repo's: a teammate on the same repo gets their own.

[How many questions your agents ask is up to you](https://hamloy.com/blog/how-many-questions-your-agents-ask) gave Pebble's agents an instruction file in the repo. This post sets the same thing from the person's side, with three settings: an interview, a medium amount, and almost none.

Everything below is copied from test runs on scratch projects, with Claude Code (Haiku 5.5) and Codex (gpt-5.6-luna).

## One task, three people

Harbor is the website of a sailing school in Muiden: three lessons in `lessons.yml`, from a €45 taster sail to a €295 beginner course. Its README says what comes next:

> Online booking for lessons: people pick a lesson and a date, pay a deposit, and get a reminder the day before.

That one sentence hides a lot of decisions. How are dates offered? How big is the deposit? Who takes the money? How does the reminder arrive? Where do bookings live?

Each agent got the same task, in a fresh repo with a board of its own:

> Plan and start building what the README says is next. Keep the work in Hamloy.

The only thing that differed was what the agent remembered about the person.

## Telling it once

For Claude Code, the person said it in a session before the work started, as anyone would:

> Remember this about me for this project: interview me. Before you build anything, every choice you'd otherwise make yourself (what it does, what people read, prices and defaults, timing, which service to use) comes to me as a question in Hamloy, one each, with the options and the one you recommend. Build only what my answers settle. Just save that to your memory; don't start any work now.

Claude saved it to its memory for that folder:

```
I've saved the rule to memory. I haven't started any work.

The saved rule: before building anything in this project, every choice
I'd otherwise make myself becomes its own question in Hamloy, with the
options and my recommendation. I'll build only what your answers settle.
```

The other two people said, in the same way:

- **Medium:**"ask me about decisions someone using the site would notice, as a question in Hamloy with the options and the one you recommend, and wait for my answer on those. Decide the rest yourself and say what you chose in a note on the task."
- **Minimal:**"don't stop for me. Make the decisions yourself, say what you chose in a note on the task, and keep going. Only ask me in Hamloy about what costs money or can't be undone."

For Codex the same words went into the person's own instructions in Codex's settings. A `~/.codex/AGENTS.md` of your own works the same way. Then each agent started a new session with the task.

## Interview: five questions, and nothing built on a guess

This is what each person found on For you afterwards:

_For you on each person's board, as they saw it. Claude Code asked everything at once; Codex asked one at a time, and the three answered so far are on Questions._

Claude Code planned the booking as four tasks and asked five questions, each with its recommendation. Each task waits on the questions it hangs on:

```
backlog
  ## Online booking
  [x] B-nmcz@3 Show the lessons and prices on the home page (done by claude on 2026-10-14)
  [] B-0p0t@1 Pick a lesson and a date (waits on Q-hhfh) (1 note)
  [] B-qg8m@1 Store bookings (waits on Q-smqw) (1 note)
  [] B-90e6@1 Take the deposit online (waits on Q-mfsp, Q-cccm) (1 note)
  [] B-0w77@1 Send the reminder the day before each lesson (waits on Q-wz02) (1 note)
```

The one thing it built was the one thing with nothing to decide. Its note on that task says so: "Nothing to decide: lessons.yml already has name, hours and price." The questions carry their reasons. Under the deposit:

```
lessons.yml has prices from €45 to €295. The deposit is what holds a spot;
the rest is paid at the school.
A fixed €50 is simple but is almost the whole price for the taster sail.
20% scales with the price and keeps the taster cheap to book.
```

Codex interviewed the other way: one question at a time. It asked what the first booking flow should sell, and stopped. Each time the person answered on the board and said "I answered it on the board.", it wrote the choice down and asked the next one:

```
Recorded: each lesson will have a school-configured fixed deposit amount.

Next Hamloy question:

1. Mollie (recommended for a Netherlands-based school)
2. Stripe
3. No online payment yet; record bookings and mark deposits manually
```

Four questions in, its board reads like the notes of an interview:

```
backlog
  [] B-snkq@5 Plan and start online lesson booking (waits on Q-xhsa) (2 notes)
questions
  [x] Q-zcy9@2 What should the first booking flow sell?
               → A fixed catalog of one-person sailing lessons with selectable dates
  [x] Q-ez4l@2 How should lesson dates be offered?
               → The school publishes confirmed date-and-time slots; customers choose an available slot
  [x] Q-p118@2 How should deposits be priced?
               → Each lesson has a school-configured fixed deposit amount
  [] Q-xhsa@1 Which payment service should collect deposits? options: 1) Mollie (for a Netherlands-based school) (recommended) 2) Stripe 3) No online payment yet; record bookings and mark deposits manually (1 note)
```

Both are interviews. Claude Code puts all its questions on the table at once, and you answer them in one sitting on For you. Codex asks one at a time, so each answer can shape the next question.

## Medium: what a visitor would notice

_For you on each person's board, as they saw it. Only what a visitor would notice came to the person._

With the medium setting, Claude Code asked three questions, all about what a visitor sees or pays: the payment provider, the size of the deposit, and whether the reminder is an email or a text. It added a request for the one thing only the person can do, an email sending account, with the steps. Then it built the part that hangs on none of them: the booking form, its checks, the bookings saved and a confirmation page. Everything else it decided itself, and its notes say what it chose:

```
Storage: SQLite via the sqlite3 gem (file under db/, git-ignored).
Routes: GET /book (form), POST /book (validate, save, show confirmation).
Lessons come from lessons.yml.
```

The visible questions were the person's. Where the database file lives was not.

Codex asked two questions, how visitors choose a date and how the deposit works, and set its booking task to wait on both. Its note says where it drew the line: "Visible choices sent to the human in Hamloy: date-selection experience and deposit model. Work is paused until those are answered; implementation choices will be recorded here."

## Minimal: only what costs money

_For you on each person's board, as they saw it. Claude Code left two choices that cost money; Codex left nothing to answer._

With "don't stop for me", Claude Code asked two questions, and both are about money: which provider takes the deposit, and which service sends the reminder emails. It built the booking form, saved the bookings, made a confirmation page and ticked them. The payment and reminder steps wait on the two questions and the Mollie account:

```
backlog
  ## Booking
  [] B-rh7x@1 Online booking for lessons (3 of 5 subtasks done) (2 notes)
    [x] B-npk8@3 Booking form: pick a lesson and a date, enter name and email (done by claude on 2026-10-14)
    [x] B-7mmi@3 Store bookings and show a confirmation page (done by claude on 2026-10-14)
    [] B-b4bm@2 Deposit payment step (waits on the payment decision and account) (waits on Q-3m44, R-1q9f)
    [] B-o62y@3 Day-before reminder email (waits on the mail account) (waits on Q-xtth)
```

Codex asked nothing. It built the booking form, its checks, the bookings saved as `pending_deposit` and a confirmation page, and left payment and the reminders as open subtasks of their own, with a note on why: "payment needs a provider/account and webhook flow; reminders need a scheduler and email delivery choice." Nothing it built costs money, and the choice of provider waits with the payment task for whoever starts on it.

## The six runs

| What the agent remembered | Claude Code | Codex |
| --- | --- | --- |
| Interview me | 5 questions at once; built only what had nothing to decide | 1 question at a time; 4 asked, 3 answered, no code on a guess |
| Ask about what a visitor notices | 3 questions and 1 request; built the booking form | 2 questions; the booking waits on them |
| Don't stop for me | 2 questions, both about money, and 1 request; built the booking form | none; built the booking form, payment and reminders left as tasks |

One run each, so these are what happened here, not a rate.

## Where you see it

Whatever the setting, the questions land in one place. For you on the board lists every question from every agent, with what each answer frees. In an interview that page is where the interview happens: answer a card, and the agent that asked hears it under its next tool reply. With the minimal setting it is nearly empty, and what is there is worth your time. The agents' notes on each task say what they decided without you, so you can read the choices you didn't make, and overturn one.

## Set it for yourself

Tell your agent, in your own words, how you want to be asked:

- **Claude Code:** say "remember this about me for this project: …" and it keeps it in its memory for that folder. To have it everywhere, put it in your own `~/.claude/CLAUDE.md`.
- **Codex:** put it in your own `~/.codex/AGENTS.md`, or in the instructions in your Codex settings.

Then run a real task and open For you. Too many questions about things you don't care about: loosen it. A choice you wanted turned up in the code: tighten it. It can change from project to project and from week to week: an interview for the launch, "don't stop for me" for a prototype. For one afternoon, say it in the chat: "don't stop for me today".

More on how questions work is in [Questions and answers](https://hamloy.com/docs/questions). To try it, [create a free board](https://hamloy.com/registration/new) and connect the agents you already use.