Spot the Bug in AI Code

Start from brute force

The obvious fix is a one-line patch that puts the system message back: [history[0]] + history[-max_turns:]. It looks right because it repairs the reported case: with six messages and max_turns = 2 it returns [sys, u4, u5]. It costs O(max_turns) time and space, the size of the tail slice. It is still wrong, because the tail can contain history[0] as well. When the whole conversation fits, as in the first example with a budget of 5, it returns [sys, sys, u1, u2]. With max_turns = 0, history[-0:] is the entire list, so it returns [sys, sys, u1, u2] again: nothing trimmed, and the instructions sent twice.

The approach

The insight is that the system message is not a turn, so it must never compete for the turn budget. Take it out of the pool before counting, apply the budget to what is left, and put it back at the front. The invariant: whatever the history length, the result is [system] followed by the newest min(max_turns, len(history) - 1) turns in their original order.

The reference does exactly that. system = history[0] pins the instruction message. rest = history[1:] holds every turn in a new list, so the input is never touched. kept = rest[-max_turns:] if max_turns > 0 else [] takes the newest turns; the guard exists because rest[-0:] is the whole list, not an empty one, and because slices clamp, a budget larger than the history keeps everything with no IndexError. return [system] + kept builds a fresh list. The TypeScript version mirrors it with slice(1), slice(-maxTurns) and the same maxTurns > 0 check.

Walk through an example

The reference run on all three examples, with the original one-liner’s output in the last row for contrast.

Complexity

Reference: O(n) time and space for n messages, because history[1:] copies every turn before the tail is taken; starting the slice at max(1, len(history) - max_turns) instead copies only the kept turns, O(max_turns). One-line patch: O(max_turns) time and space for its single tail slice, but it duplicates the system message whenever that slice reaches index 0.

Edge cases to test

• max_turns = 0: [sys]. rest[-0:] is the whole list in Python, and slice(-0) is the whole array in JavaScript, so the explicit guard is required.
• No turns yet, [sys] with max_turns = 3: [sys]. rest is empty, and so is kept.
• A budget that exactly fits, [sys, a, b] with max_turns = 2: returned unchanged. The original one-liner already fails here and returns [a, b], because three messages exceed a budget of two.
• A budget larger than the history, [sys, u1, u2] with max_turns = 5: returned unchanged. Slices clamp to the list in both languages, so no length check is needed.
• Editing a returned message: the list is new, but the message dicts are shared with the input, so setting result[0]['content'] also changes history[0]. Copy the dicts if callers may modify them.

Common mistakes

• Slicing the whole history instead of history[1:], so the system message competes for the turn budget.
• Forgetting the max_turns == 0 case — x[-0:] is the whole list, not empty, a classic Python trap.
• Mutating the input list instead of building a fresh one.
• Fixing the symptom (“keep it under N”) without asking whether the system prompt must always survive — it must.
• Patching with [history[0]] + history[-max_turns:]: once the whole history fits, the tail already includes history[0], so the system message is sent twice.

Follow-ups an interviewer asks next

The budget is tokens, not turns.

Reserve the system prompt’s tokens first, then walk the turns from newest to oldest, adding each message’s token count, and stop before the first one that would exceed what is left; keep that suffix in original order. Never split a message, and keep an assistant tool call together with its tool result, since chat APIs reject a tool result whose call was trimmed away.

Trimming drops facts the user stated early in the chat.

Summarize instead of discarding. When turns fall out of the window, fold them into a running summary message placed right after the system prompt, and update it as more turns age out. The system message stays pinned, the summary carries the old context in far fewer tokens, and the recent turns stay verbatim.

Several messages must survive, not just history[0].

Generalize the split: partition the messages into pinned ones (the system prompt, a summary, a document the user attached) and trimmable ones, apply the budget only to the trimmable list, then merge both back in original order. The invariant is unchanged: nothing pinned ever counts against the budget.

Where this shows up

Dropping the system prompt on long conversations is a real, shipped bug pattern in AI apps — the assistant silently “forgets” its instructions mid-chat. More broadly this is what reviewing AI-generated code is: the code looks right, passes the obvious case, and fails on the case that matters. Catching it means reading for the edge (long history) the demo never exercised — the core skill of shipping with AI.

Reference solution

def clip_history(history, max_turns):
    system = history[0]
    rest = history[1:]
    kept = rest[-max_turns:] if max_turns > 0 else []
    return [system] + kept


sys = {"role": "system", "content": "S"}
long_hist = [sys] + [{"role": "user", "content": str(i)} for i in range(5)]
print(clip_history(long_hist, 2))
# -> [system, {'2'}, ... ] keeps system + last 2 turns

type Msg = { role: string; content: string };

function clipHistory(history: Msg[], maxTurns: number): Msg[] {
  const system = history[0];
  const rest = history.slice(1);
  const kept = maxTurns > 0 ? rest.slice(-maxTurns) : [];
  return [system, ...kept];
}

const sys = { role: 'system', content: 'S' };
const longHist = [sys, ...[0, 1, 2, 3, 4].map((i) => ({ role: 'user', content: String(i) }))];
console.log(clipHistory(longHist, 2));
// -> [system, {content:'3'}, {content:'4'}]