Cut Travel Agency Itinerary and Proposal Time in Half with Claude Code

It’s Friday at 5 p.m. A couple walks up to my counter: “We want two nights in Kyoto next weekend, budget around $1,400, we’d love to see the fall colors and have a proper kaiseki dinner.” That’s a great brief. But the first thing that flashed through my head was the two hours I was about to spend.

Check room availability. Map out travel times. Add up the numbers on a calculator. Type it all cleanly into Word. Paste in the terms and conditions. Fix the typos at the end. Two hours for a single proposal. Stack a few of those into one day and you go home with a pile of “I’ll rebuild that one tomorrow.” You end up spending more time filling in blank template fields than actually looking your customer in the eye. That, honestly, is a pretty realistic day in the life of a travel agency planner.

I handed the “assemble and write up” part of that job to Claude Code and generative AI. The short version: a single proposal went from two hours down to about 50 minutes. But you can’t just throw the whole thing over the wall. The trick was drawing a hard line between what I delegate and what a human always keeps a hand on.

Key takeaways

• Assembling and writing up itineraries, quotes, and proposals is something AI is good at. That frees the planner to focus on choosing destinations and talking to customers.
• I’ve included a prompt template you can lend out as-is, plus a verification script that catches pricing math errors mechanically.
• Numbers where a mistake becomes an incident, prices, inventory, cancellation policies, are always checked by a human. Drawing that line is the condition for using this safely.
• Black out personal data like names and booking numbers before handing anything to the AI. Decide the “never paste raw data” rule up front.
• Two hours down to 50 minutes. At 60 proposals a month, that’s roughly 70 hours saved, by my rough math.

Where exactly is the weight in travel agency work

You’re probably a planner who builds custom trips, either at a storefront or in corporate sales. The more your work leans toward listening to requests and building from scratch, rather than selling packages, the more this article should land.

A custom proposal usually moves through these steps.

1. Intake: ask about destination, party size, budget, preferences, and non-negotiables.
2. Sourcing: research candidate hotels, transport, and local experiences along with their prices.
3. Assembly: drop everything onto a schedule while watching travel times and availability.
4. Quoting: add up lodging, transport, handling fees, and tax to land on a total.
5. Write-up: format it into an itinerary and proposal and attach the fine print.
6. Present and revise: hand it to the customer and fold in changes like “make day two more sightseeing-heavy.”

Of these, steps 1 and 6 can only be done by a human. They’re about reading a customer’s expression and their honest take on budget. Steps 3 through 5, on the other hand, are about pouring fixed materials into a fixed mold. That’s where one to two hours go every single time, and you redo the same work every time there’s a revision. That’s exactly where the rework hides.

The moment someone says “could we slow day two down a bit,” the travel times and the prices all have to be rebuilt. You shift one Excel row, the total stops adding up, and you don’t notice until you’ve already sent it and your face goes red. These small incidents are quietly common on the floor.

What to delegate to AI versus what a human always decides

Leave this fuzzy and you’ll have an incident. Let’s draw the line first.

Step	Delegate to AI	Human always decides
Intake	Check for missing questions	The honest budget, rapport, reading the mood
Sourcing	Background research, building comparison tables	Final stock/availability check, what to recommend
Assembly	A draft schedule that accounts for travel time	Whether the flow is realistic and matches stamina
Quoting	Building the formulas, drafting the total	Cost prices, exchange rates, cancellation figures
Write-up	Formatting into itinerary and proposal, typo check	Final sign-off, locking in the customer’s name

There’s only one line worth memorizing. Any number where a mistake turns into a refund or a complaint gets checked by a human, always. Price, availability, cancellation fees, age-based rates, exchange rates. You don’t take the AI’s draft at face value here; you reconcile it against the official rates from your supplier. The AI is a fast write-up clerk, not a pricing guarantee.

Use case 1: Turn a request memo into a draft itinerary

Intake notes are usually a scattered bullet list. Turning that into the shape of a schedule used to be where I spent the most time. That’s what I hand to the AI.

Here’s a prompt template you can use as-is.

You are a veteran planner at a travel agency.
From the request memo below, build a draft itinerary with realistic travel times.

# Request memo
- Destination: Kyoto
- Dates: 3 days, 2 nights
- Party: a couple, 2 people
- Budget: around $1,400 total
- Wishes: fall-color spots, kaiseki dinner at night, don't cram the travel

# Output rules
- Split each day into morning / afternoon / evening
- Give each item an estimated duration and a mode of transport
- Mark any leg over 1 hour with "[long leg]"
- Where a price is needed, write [TO CONFIRM: price] and never fill in numbers
- At the end, list the items that need confirmation as bullet points

The last two lines are the crux. Don’t let the AI fill in prices; leave a [TO CONFIRM: price] placeholder. That prevents the incident where the AI writes a plausible-looking fake price. Then you pour your own official rates, the ones you got from the supplier, into the draft. With that division of labor, I can use it without worry.

If you’re not yet comfortable with the basics of Claude Code, read the Claude Code getting started guide first so you can try this template right away.

Use case 2: Catch quote-total errors mechanically

The scariest thing in a proposal is a pricing addition error. One night with two meals times the party size, tax and service charge, handling fee. Build it in Excel, add a row, and the sum range slips, so you send a lower number without noticing. That’s the apologize-and-eat-the-difference path.

So I prepared a script that checks the quote breakdown mechanically. It runs anywhere you have Node.js. All it does is re-add every line in the breakdown and verify that it matches the total you’re presenting.

// verify-quote.mjs  Check that the line items and the total agree
// Run: node verify-quote.mjs

const quote = {
  customer: "(redacted)",
  items: [
    { label: "Lodging night 1, Inn A, 2 people", amount: 48000 },
    { label: "Lodging night 2, Inn B, 2 people", amount: 52000 },
    { label: "Bullet train, round trip, 2 people", amount: 56000 },
    { label: "Local guide, half day", amount: 18000 },
    { label: "Handling fee", amount: 8000 },
  ],
  tax: 14400, // consumption tax, etc.
  presentedTotal: 196400, // the total written in the proposal
};

const subtotal = quote.items.reduce((sum, item) => sum + item.amount, 0);
const calcTotal = subtotal + quote.tax;

console.log(`Subtotal:        ${subtotal.toLocaleString()}`);
console.log(`Tax:             ${quote.tax.toLocaleString()}`);
console.log(`Calculated total: ${calcTotal.toLocaleString()}`);
console.log(`Proposal total:   ${quote.presentedTotal.toLocaleString()}`);

if (calcTotal === quote.presentedTotal) {
  console.log("OK: line items and total agree");
} else {
  const diff = quote.presentedTotal - calcTotal;
  console.log(`NG: off by ${Math.abs(diff).toLocaleString()}. Fix it before sending the proposal.`);
  process.exit(1);
}

Set presentedTotal to the number on the proposal and the script stops with NG the instant anything is off. It’s the last gatekeeper before the customer sees it. The line-item amounts themselves are assumed to be values a human confirmed with the supplier; this script only re-checks the math. Treat verification and price confirmation as separate jobs, that’s what matters.

If you want to push your prompt accuracy further, see advanced prompt engineering tips as well.

Use case 3: Apply “slow down day two” in one shot

Revisions after presenting are where the AI really earns its keep. I used to rebuild both the schedule and the pricing by hand every time a request came in. Now I ask it like this.

Apply the following changes to the itinerary above.
- Day 2: drop one morning item, and add a 1-hour rest at the hotel in the afternoon
- Rewrite the durations for any legs whose travel changes as a result
- Reset any item whose price changes back to [TO CONFIRM: price]
- Prefix each changed spot with "* CHANGED" and explain in one line what you changed

Asking it to “mark the changed spots” is the trick. You can see at a glance what moved, so your own check takes a second. Items whose price shifts get reset to [TO CONFIRM: price], and the recalculation stays in human hands. That made the “thought I revised it, but the total is still the old number” incident disappear.

If you teach your project the itinerary and proposal templates up front, you don’t have to give instructions from zero every time. The CLAUDE.md best practices guide is a good reference for how.

A copy-paste pre-send checklist

Run every proposal through this before sending, on paper or in a note, whatever works.

• Did you reconcile prices against the supplier’s official quote?
• Did you do a final check on availability and inventory? (Not trusting the AI draft?)
• Did you put the cancellation policy and age-based rates in the body?
• Did you run the verification script and confirm the total matches?
• Did you restore the customer’s name and booking number to the correct spelling?
• Is the travel time realistic? (Especially for elderly travelers or families with small kids.)

Personal data and security notes

Travel arrangements are a pile of sensitive data: names, dates of birth, passport numbers, booking numbers. Pasting that straight into an AI is something I avoid.

The operating rules are simple, just two. One, black out personal data before handing it over. Replace the name with “Guest A” and the booking number with “(redacted).” You don’t need real names to assemble or write up a trip. Two, keep the raw data local, and have a human do only the final name merge by hand. Let the AI build the mold; fill in the personally identifying information at your desk. Keep that order and nothing you’d regret leaking ever leaves.

If you’re rolling this out as a company, it’s safer to put in writing what’s okay to share and what’s off-limits. We can sort out that team line-drawing together in training and consulting. Hand a fuzzy judgment standard to everyone and someone will inevitably paste raw data.

What changed before and after

Lay it out in numbers and the change is clear.

Item	Before	After
Time to write one proposal	~2 hours	~50 minutes
Time to apply one revision	~40 minutes	~10 minutes
Total-calculation errors	Occasional	Caught by verification before sending
Where the planner’s focus goes	Write-up and calculator	Choosing destinations and serving customers

Here’s a rough ROI estimate. Say you build 60 proposals a month. At 70 minutes saved per proposal, that’s roughly 70 hours freed up in a month. You can pour that time into finding better destinations or adding extra suggestions. That, to me, is the biggest value here.

If you’re worried about whether a non-engineer can use this, reading Claude Code for non-engineers should lower the bar for the first step.

FAQ

Q. I’m worried the AI will just decide prices on its own. A. Use [TO CONFIRM: price] in the prompt so it never fills in numbers. Only values a human confirmed with the supplier go in. Fix the AI’s role as the formula-and-write-up clerk and it won’t run off the rails.

Q. Is it okay to enter the customer’s real name and booking number? A. Don’t. Black them out before handing it over, and do only the final name merge by hand. You don’t need personal names to assemble and write up.

Q. We have our own itinerary template. Can it be reproduced? A. Yes. Teach the project your own mold and formatting rules and it’ll produce output in that shape every time. For the details, check the configuration instructions in the official documentation.

Q. Can I fully automate this and skip human review? A. I don’t recommend it. The premise is that a human keeps a hand on price, inventory, and cancellation-policy checks. Skip that and the mistakes go straight to the customer. The safe move is to limit the time savings to “assemble and write up.”

How it went when I actually tried it

I ran the “two nights in Kyoto” case from the opening through this exact flow, start to finish. Getting from the request memo to a draft itinerary took about 8 minutes. I poured in the official rates I got from the supplier and ran it through the verification script, and at first it was off by about $14 because of a typo on my end, and it stopped with NG like it should. Catching that before sending was the biggest win of all.

After that the customer came back with “slow day two down,” but because I’d had it mark the changed spots, I swapped it out in under 10 minutes, review included. All told, what’s usually a two-hour ordeal came in around 50 minutes. The time I saved even gave me room to add one more suggestion, a hidden fall-color spot.

I confirmed three things. That the no-filling-prices approach keeps fake numbers from appearing, that verification stops total errors before they go out, and that revisions apply without rework. With those three in place, my honest read is that you can confidently hand travel agency proposal-building over. Start with one proposal, on a job where a stumble wouldn’t scare you. If you get stuck on the first steps, starting from the Claude Code getting started guide is the shortcut.

For the official how-to, see the Claude Code official documentation as well.