Prompt Engineering

Split Large Codebase Context — File Boundaries, Atomic Fences

Code split mid-function is unreviewable. Codebase mode splits at file boundaries, keeps fenced blocks atomic, and lists the files in every chunk.

Open in Long Prompt Splitter

Overview

Splitting source code is where blind chunking fails hardest: a function severed across messages, a fence broken so the syntax highlighting collapses, files blended into anonymous soup. Codebase mode treats code as code: file markers become preferred boundaries, fenced blocks are atomic units the packer never breaks when avoidable, every chunk carries its own file list, and the model is told not to review anything until the final chunk declares the codebase complete. This setup loads a multi-file billing module with the review task delivered exactly when it should be — after everything has arrived.

How to use this resource

Keep the file markers

"File: src/…" lines become split boundaries and per-chunk inventories — structure in, structure out.
Trust the atomic fences

Fenced blocks travel whole; a forced continuation is explicitly marked, never silent.
Review only when complete

The final chunk declares the codebase complete and triggers the task — no premature reviews of half a module.

Why This Works

File-aligned chunks keep code referenceable by name and location
Atomic fences preserve the syntactic integrity reviews depend on
The completion gate stops reviews of half-delivered code

Best for

Code reviews that span more files than one message holds
Sharing project source with file structure intact
Developers whose pasted code keeps getting answered early

Not for

Writing the review contract itself — that's the Code Review Prompt Generator
Estimating how many files fit per chunk — that's the Context Window Estimator's codebase budgeting

Use cases

Feeding a multi-file module into one conversation
Keeping functions and fences intact across chunks
Holding the review until the codebase is complete

FAQ

How do I send a multi-file codebase to AI without breaking functions across messages

Codebase Mode prefers file boundaries as split points and keeps fenced blocks atomic, so a function isn't severed mid-message. Long Prompt Splitter produces the numbered chunks; you send each as one message and wait for the model's "Received chunk i of 3" acknowledgement before the next, keeping the delivery ordered and referenceable.

How do I stop the model reviewing my code before all the files arrive

Each chunk header says do not review, fix, or execute anything yet, and the TASK to review the billing module runs only after the ALL CHUNKS DELIVERED gate declares the codebase complete. That completion gate is what prevents a premature review of half a module, so the review runs against the whole thing.

How will I know which files landed in each chunk

Every chunk carries its own "Files in this chunk" list, for example src/billing/proration.js and src/billing/invoice.js, alongside "### File:" markers that double as split boundaries. That way you can name the file and chunk for any claim, which the final gate explicitly asks you to preserve when referencing code.

Customize This Resource

Opens this scenario in Long Prompt Splitter. Split to get the full chunked package — then adjust the chunk size and delivery mode.

Open in Long Prompt Splitter

Prompt Template

Copy it as-is, or use Open in Long Prompt Splitter to load it pre-filled and customize it with your own context.

CHUNKED CONTEXT PACKAGE

DELIVERY INSTRUCTIONS
- Send each chunk below as ONE message, in order, starting with Chunk 1.
- Wait for the model's acknowledgement ("Received chunk i of 3") before sending the next chunk.
- Do not edit the chunk contents — the markers and the content are designed to travel together.

CHUNK STRATEGY
- Content: 21,812 characters, ~6,059–7,791 tokens (Code).
- Target model: Claude Sonnet (200,000-token window; verified June 2026).
- Chunk budget: ~4,000 tokens (11,200 characters max per chunk) → 3 chunks.
- Delivery mode: Codebase Mode — Code-optimized delivery — file boundaries preferred, fenced blocks kept atomic, per-chunk file lists included.
- Boundary quality: 2 section breaks, 0 paragraph breaks, 0 line-level breaks, 0 hard cuts.

===== CHUNK 1 of 3 =====
- This content is source code arriving in 3 parts, in order. File markers label each file; chunk breaks follow file boundaries where possible.
- Do not review, fix, or execute anything yet — wait until the final part announces the codebase is complete.
- Files in this chunk: src/billing/proration.js, src/billing/invoice.js
- After reading, reply ONLY: "Received chunk 1 of 3." Then wait for the next chunk.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.


----- END OF CHUNK 1 of 3 — do not respond yet; chunk 2 follows -----

===== CHUNK 2 of 3 =====
- Chunk 2 of 3 — part of the same continuous content. The earlier rules still apply.
- Files in this chunk: src/billing/invoice.js, src/billing/proration.js
- After reading, reply ONLY: "Received chunk 2 of 3." Then wait for the next chunk.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.


----- END OF CHUNK 2 of 3 — do not respond yet; chunk 3 follows -----

===== CHUNK 3 of 3 =====
- Chunk 3 of 3 — part of the same continuous content. The earlier rules still apply.
- Files in this chunk: src/billing/proration.js, src/billing/invoice.js

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

### File: src/billing/proration.js

```
export function prorate(plan, daysUsed, daysInCycle) {
  const daily = plan.priceCents / daysInCycle;
  const used = Math.round(daily * daysUsed);
  return { usedCents: used, creditCents: plan.priceCents - used };
}
```

The proration helper assumes calendar billing cycles; anniversary cycles are normalized upstream before this function is called.

### File: src/billing/invoice.js

```
export function buildInvoice(account, items, credits) {
  const subtotal = items.reduce((s, i) => s + i.amountCents, 0);
  const credit = credits.reduce((s, c) => s + c.amountCents, 0);
  return { accountId: account.id, totalCents: Math.max(subtotal - credit, 0), lineCount: items.length };
}
```

Invoices clamp at zero; negative balances roll into the credit ledger rather than producing negative invoices.

===== ALL 3 CHUNKS DELIVERED =====
- All 3 chunks are delivered — consider the codebase complete.
- Preserve file boundaries when referencing code: name the file and chunk for every claim.

TASK
Review the billing module for correctness and edge cases once all chunks arrive.

NOTE
- Chunk budgets use character-based token estimates, not tokenizer output; model windows verified June 2026.

More resources from Long Prompt Splitter

Resource

Message Too Long — the Fix That Doesn't Butcher Content

The "message too long" error has a structural fix: split at paragraph boundaries into sequenced chunks with wait rules, instead of pasting fragments and hoping.

Prompt Engineering

Resource

Split Large Prompts — Boundary-Aware, Never Blind

Splitting a long prompt by character count butchers it. Boundary-aware chunking splits at sections and paragraphs, keeps code blocks atomic, and counts every forced cut.

Prompt Engineering

Resource

Chunk Long Documents — Sections Survive the Split

Documentation mode chunks structured documents at heading boundaries, tells the model to reconstruct the section structure, and answers with original headings.

Prompt Engineering

Resources that pair well

Resource

Estimate Token Budget — Plan Before You Paste

Token budget planning for real workloads: how much of the window a transcript actually consumes, what is left for the answer, and how much headroom remains.

Prompt Engineering

Resource

AI Session Handoff — Shift Change for Working Sessions

End a working session like a shift change, not an abandonment: state captured, decisions logged, next step named — ready for the next session to pick up.

Prompt Engineering

Resource

Package Long Documents for AI — Delimiters and § Labels

Pasting a document raw mixes material with instructions. Package it: explicit delimiters, citable [§N] section labels, and grounding rules — the source travels verbatim.

Prompt Engineering

Related tools

Tool

Long Prompt Splitter

Split oversized content at meaningful boundaries into sequenced chunks with continuity markers and wait rules.

Context Tools

Guides for this resource

Guide

Make AI Explain Unfamiliar Code Before You Change It

Type "refactor this" on code you don't fully understand and the AI — which understands it no better — rewrites a load-bearing line. Here's how to run an explanation pass first: what the code does, what it assumes, and which lines are risky to touch, before you change anything.

Software Development with AI

Tip: Save time by exploring related resources and tools that integrate with this resource.