Day 2 Afternoon — Hands-On Exercise

🛠️ Build Your First Agent

Set up your project, write steering rules, save a Skill, find a real error, and schedule it to run automatically. No coding required.

⏱ 75 minutes · Claude Cowork · No coding · Invoice processing use case
0Reconnect
1Instructions
2Read Files
3Save Skill
4Iterate
5Schedule
+Team

What You're Building

By the end of this exercise you'll have a working invoice processing agent in Claude Cowork — one that extracts data, validates arithmetic, matches purchase orders, flags exceptions, and runs automatically every Monday morning. No code.

Step What you do Cowork layer Time
0Reconnect to your project from Day 1Project workspace5 min
1Write your Project Instructions (steering rules)Project Instructions10 min
2Mount the invoice folder — ask Claude to read the filesFile access10 min
3Save your invoice processor as a named SkillSkill20 min
4Feed invoice_006 — find the error — update the SkillSkill iteration15 min
5Schedule: every Monday 8am, check the folder automaticallyScheduled Task10 min
🏗️
Building on Day 1: Your Executive Decision Brief template from yesterday is the seed of your first Skill. In Step 3 you'll convert it from a prompt you paste into an instruction Claude follows automatically. Everything you learned about persona, Chain-of-Thought, and structured output applies directly here.
0Reconnect to Your Project

Step 0: Open Your Finance Risk Assistant Project

Yesterday you created a Cowork project called Finance Risk Assistant and ran your Day 1 prompt exercise inside it. Today you're coming back to the same project to build on it. Everything you did yesterday is still there.

🖥️ Do this now

  • Open Claude Cowork on your Windows desktop
  • In the left sidebar, find and click Finance Risk Assistant
  • You should land inside your project — previous conversations are visible in the history
  • Start a new conversation inside the project (click the pencil / new chat icon)

✅ Confirm it worked — type this to Claude:

Type to Claude
What are my project instructions for this project?

Claude should recite back the rules you wrote yesterday. If it doesn't, your Project Instructions field is empty — you'll fill it in Step 1 now. Either way is fine.

💡
Why we use the same project: A Cowork project is your agent's persistent workspace. Skills you save here, rules you set here, files you connect here — all stay across sessions. Coming back to the same project means your agent picks up where it left off, not from zero.
1Project Instructions

Step 1: Write Your Steering Rules (10 min)

Project Instructions are the always-on rules Claude follows for every conversation in this project — without you repeating them. Think of the 3 things your team would be furious if Claude got wrong. Those are your rules.

💡 Open your Project Instructions and write 5–7 rules

Click the notepad / project settings icon at the top of your project. A text area will open — this is your Project Instructions field. Write your rules here.

Your rules should cover at least:

  • Currency — all amounts in SGD unless specified
  • PII — never include real customer names, IDs, or account numbers in output
  • Escalation threshold — flag anything above a dollar amount for human review
  • My role — tell Claude who you are and what team you work in
  • Output style — concise and decision-focused; your audience is senior leadership
Starter — Project Instructions template (paste into the field, then customise)
# AnyCompany Finance — Project Rules ## Who I Am I work in AnyCompany Financial Group, Finance Solutions Excellence team. My audience for outputs is senior finance leadership and the CFO office. ## Always Apply These Rules 1. All monetary amounts must be in SGD unless I specify otherwise 2. Never include real customer names, NRIC/FIN numbers, or account numbers in any output 3. Flag any invoice or transaction above SGD 25,000 as HIGH VALUE — requires human review 4. When uncertain about a fact, say "I need more data" rather than guessing 5. Risk ratings use GREEN / AMBER / RED only — no other scale 6. Every factual claim must cite specific numbers from the data provided 7. Keep outputs concise and decision-focused — no essays

💡 This is a starting point — customise at least 2 rules to reflect your actual team's standards before moving on.

✅ Confirm it worked — type this to Claude:

Type to Claude
Summarise your project rules in 3 bullet points.

Claude should summarise the rules you just set. If it gives generic advice instead of your specific rules, check that you saved the Project Instructions field (some UIs require pressing Enter or clicking a Save button).

2Read the Invoice Files

Step 2: Connect the Invoice Folder (10 min)

Claude Cowork can read files directly from a folder on your computer — no uploading, no copy-pasting. You point it at a folder, and it can access every file inside. This is what makes the difference between a chatbot and an agent.

📂 Connect the workshop folder

  • In your project, look for "Add folder" or "Connect files" (folder icon in the sidebar or conversation)
  • Navigate to the Desktop → workshop-data → cowork-lab2-invoice-agent folder
  • Approve the access request — Cowork will confirm the folder is connected
  • You should see the folder listed in your project sidebar

✅ Confirm Claude can see the files — type this:

Type to Claude
How many invoice PDF files are in the connected folder? List their filenames.

Claude should respond with 6 files: invoice_001.pdf through invoice_006.pdf. It will also mention purchase_orders.csv and validation_rules.json. If it says it can't find files, the folder connection may not have completed — try disconnecting and reconnecting it.

🔍
What's in the folder: 6 invoices from Southeast Asian vendors (PT Mitra Teknologi, SG CloudServe, Bangkok Digital, KL Fintech, Saigon Data Systems, Manila Tech Partners), a purchase_orders.csv file for matching, and a validation_rules.json with escalation thresholds. One of the invoices has a deliberate error — you'll find it in Step 4.
3Save Your First Skill

Step 3: Convert Your Template to a Skill (20 min)

Now you'll take your Day 1 Executive Decision Brief template and adapt it for invoice processing — then save it as a permanent Skill. You're not building something new from scratch; you're upgrading what you already built.

💡 Part A — Build the invoice processor prompt (10 min)

Start a new conversation in your project and build an invoice processing prompt step by step. Your prompt should tell Claude to:

  • Act as a Senior AP Analyst (persona — same technique as Day 1)
  • Extract all fields from the invoice: vendor, number, date, line items, totals
  • Verify arithmetic: multiply qty × unit price for every line; compare to printed subtotal
  • Match to purchase_orders.csv and calculate variance percentage
  • Flag exceptions using the rules in validation_rules.json
  • Output a structured status block per invoice, then a batch summary

Test it first — paste the text of invoice_001.pdf manually. Does the output look right? Iterate until it does.

💡 Part B — Save it as a Skill (5 min)

Once the output looks right, tell Claude to save it:

Type to Claude — save the skill
Save this as a skill called "invoice-processor". It should activate when I ask you to process, validate, or review vendor invoices.

✅ Confirm the Skill was saved — type this:

Type to Claude
List my saved skills.

You should see invoice-processor in the list. This confirms Claude has saved the Skill to your account — it now persists across all future sessions. You don't need to retype that prompt again, ever.

⚠️
Skill not listed? Try: "What skills do I have saved?" or "Show my saved skills." If still nothing, try saving again and include more detail in your prompt before saving — Claude saves the content of the current conversation, so make sure the full instructions are visible in the chat before asking it to save.

If your Day 1 template didn't come out strongly enough to adapt, use this pre-built starter Skill instead. Paste it into the chat, then ask Claude to save it.

name: invoice-processor
description: Use when processing vendor invoices — extracting line
  items, verifying arithmetic, matching POs, and flagging
  exceptions for the AP team review queue.
---

## Role
You are a Senior AP Analyst at AnyCompany Financial Group.
You are precise and conservative — flag anything uncertain
rather than making assumptions.

## Instructions
1. Extract: vendor, invoice number, date, due date, all line
   items (description, qty, unit price, amount), subtotal,
   GST %, total due
2. Verify arithmetic: sum (qty × unit price) for all lines;
   compare to printed subtotal; note any discrepancy
3. Match to purchase_orders.csv: find vendor PO, compare
   approved amount to invoice total
4. Calculate variance: (invoice − PO) / PO × 100%
5. Apply escalation rules → 6. Output structured result

## Escalation Rules
- Variance > 2%:              AMOUNT MISMATCH
- No PO found:               NO PO — manual approval required
- Arithmetic error:          ARITHMETIC ERROR
- GST ≠ 9% (SG vendor):     GST DISCREPANCY
- Total > SGD 25,000:        HIGH VALUE — escalate to Head of Finance

## Output per invoice
**[INV NUMBER] — [VENDOR]**
Status: ✅ PASS / ⚠️ EXCEPTION / ❌ FAIL
Total: SGD [x]  |  PO: [PO-xxx]  |  Variance: [x]%
Flags: [list or "None"]  |  Action: [next step]

BATCH SUMMARY: [n] invoices | [n] pass | [n] exceptions | SGD [total] flagged

## Guardrails
- Never approve — flag or pass only. Approval is human.
- If PO match is ambiguous, flag NO PO FOUND — do not guess
- All amounts in SGD; flag CURRENCY MISMATCH if another detected

Paste this into Claude, then say: "Save this as a skill called invoice-processor. Activate when I ask to process vendor invoices."

4Iterate — Find the Error

Step 4: Test on invoice_006 — Then Improve the Skill (15 min)

Your Skill is saved, but it's not finished. A Skill that only works on clean invoices isn't production-ready. Time to stress-test it with a deliberately broken invoice — and update the Skill when it misses something.

🔍 Part A — Run the Skill on invoice_006 (5 min)

Ask Claude to process the last invoice in the folder:

Type to Claude
Process invoice_006.pdf using the invoice-processor skill. Check it against the purchase orders and flag any issues.
🔎
Look carefully at the output. Does it flag an arithmetic error? Invoice_006 is from Manila Tech Partners. The line items add up to SGD 12,500 — but the printed subtotal says SGD 13,800. If your basic Skill doesn't catch this, that's the gap we're about to close.

🔧 Part B — Update the Skill (10 min)

Whether or not your Skill caught the error, add an explicit arithmetic verification rule. Tell Claude to update the Skill:

Type to Claude — update the skill
Update the invoice-processor skill. Add a rule: for every invoice, manually calculate the sum of (qty × unit price) for all line items. If this calculated total does not match the printed subtotal, flag it as ARITHMETIC ERROR and show both the expected total and the printed total in the output.

✅ Re-run on invoice_006 to confirm the fix:

Type to Claude
Re-process invoice_006.pdf with the updated skill.

You should now see: Flags: ARITHMETIC ERROR — line items sum to SGD 12,500.00, printed subtotal SGD 13,800.00 (difference: SGD 1,300.00)

🔄
You just ran the agentic loop — on a real invoice.

Remember the four stages from this morning? Here's exactly what just happened:

👁️
Observe
Claude read invoice_006.pdf and extracted all fields including the printed subtotal of SGD 13,800
🧠
Plan
Claude decided which Skill rules applied: arithmetic verification, PO matching, escalation thresholds
⚡
Act
Claude calculated 6,500 + 2,800 + 1,200 + 2,000 = 12,500 and compared it to the printed 13,800
🪞
Reflect
Claude identified a SGD 1,300 discrepancy and flagged it as ARITHMETIC ERROR with full detail

The Skill is the plan. The agentic loop is how Claude executed it. Every time you improve the Skill, you improve what Claude plans to do — without rewriting any code.

🏭
This is also "Python vs LLM" in action. Detecting that 6,500 + 2,800 + 1,200 + 2,000 = 12,500 ≠ 13,800 is arithmetic — a deterministic check. Ideally a script would do this faster and cheaper. But for a business user with no code? The LLM with an explicit arithmetic rule gets you 90% of the way there in 10 minutes. Your tech team can optimise it later with a script — the Skill instruction becomes the spec for what to automate.
5Schedule It

Step 5: Make It Run Automatically (10 min)

Right now your Skill only runs when you ask. The final step is making it run on its own — this is what separates a useful tool from an autonomous agent. You describe what you want, when you want it, and Claude sets it up.

⏰ Create a Scheduled Task — just tell Claude what you want

You don't need to configure anything. Just describe the schedule in plain English:

Type to Claude
Schedule this to run every Monday at 8am: Check the connected invoice folder for any new PDF files added since last Monday. Run the invoice-processor skill on each new file. Send me a summary of results — how many invoices processed, how many passed, how many had exceptions, and the total SGD value of exceptions.

✅ Confirm the Scheduled Task was created:

Type to Claude
Show my scheduled tasks.

You should see the Monday 8am task listed. You can also find it in the Scheduled Tasks panel in the Cowork sidebar — look for the clock/calendar icon. The task shows the schedule, when it last ran, and when it next runs.

🧪 Trigger it manually to verify it works now:

Type to Claude
Run the Monday invoice check now as a test — use all 6 invoices in the folder.

You should get a batch summary across all 6 invoices. Invoice_006 should appear in the exceptions with the arithmetic error flagged.

🔗
What connects morning to afternoon:
  • The Chaining workflow pattern (read → extract → match → flag → summarise) is exactly what your agent just ran
  • The Scheduled Task is the Cowork equivalent of a Hook — when Monday arrives, action starts automatically
  • The Skill is your Project Instructions applied to a specific task — just as the Automation Stack explainer described
  • The agentic loop ran 6 times in sequence — once per invoice — orchestrated by your single scheduling instruction
💬
What about connecting to a real shared folder? Right now the agent reads files from a local folder on your Windows desktop. If your AP team uses Google Drive or SharePoint, your IT team can install the relevant Plugin — and the same Scheduled Task will read from the live shared folder automatically. The Skill and schedule you built today stay exactly the same. Only the data source changes.
+Team Setup — Optional Extension

Working With a Colleague? Set Up Shared Context (10 min)

If someone else from your team will also work on this project, there's one important thing to know: Claude doesn't share memory between accounts. Your colleague's Claude won't know what you built or decided — unless you put that context somewhere both Claude instances can read.

The fix is simple: create three shared files in your project folder. Both of your Claude instances can read files from the mounted folder, so anything you put there becomes shared working memory.

⚠️
Common wrong assumption: "I told Claude about the new escalation threshold — my colleague's Claude knows now." It doesn't. Auto-memory is private to your account. The only way a decision reaches your colleague's Claude is through a shared file.

📁 Create these three files in your project folder

Ask Claude to create all three in one go:

Type to Claude
Create three collaboration files in the connected folder: 1. CONTEXT.md — current project state: active rules, current thresholds, what's in progress, what's blocked. Start with what we've set up today (Project Instructions rules, invoice-processor skill, Monday 8am scheduled task, invoice folder connected). 2. SESSION_LOG.md — an append-only session log. Add the first entry: today's date, what we built (project setup, invoice-processor skill v1, scheduled task), and what's still open (testing with real invoices, IT Plugin approval pending). 3. DECISIONS.md — a decision registry. Add the first entry: escalation threshold set at SGD 25,000, GST check for SG vendors at 9%, skill created with arithmetic verification rule.

📏 Add this to your Project Instructions (and share the wording with your colleague)

This one line makes Claude automatically read the shared context at the start of every conversation:

Add to Project Instructions
At the start of each session, read CONTEXT.md from the connected folder. It is the shared project brief — it tells you current rules, recent decisions, and what is in progress. Treat it as authoritative if it conflicts with your memory.

✅ The handoff habit — end of every session, type this:

End-of-session update
Update CONTEXT.md with anything that changed today. Append a brief entry to SESSION_LOG.md noting what we worked on, what changed, and what's still open.

Your colleague starts their next session, Claude reads CONTEXT.md automatically, and already knows the current state. No briefing overhead. No "I thought we changed that threshold" confusion.

🎯
The broader principle: In any AI tool — Cowork, Claude.ai, or any future tool — memory is always per-user. The shared folder, shared documents, and shared files are your team's shared AI context. Build the habit of externalising decisions into shared files, not just into private memory. This is what makes AI tools work for teams, not just individuals.

🏆 What You Built Today

In 75 minutes, starting from a Day 1 prompt template, you built a working invoice processing agent. Here's what you're taking home:

📏
Project Instructions
7 standing rules that apply to every conversation in your Finance Risk Assistant project — currency, PII, escalation thresholds, output style. Claude follows these automatically, forever.
🧠
invoice-processor Skill
A saved, named Skill that extracts, validates, matches, and flags invoices. Includes the arithmetic verification rule you added in Step 4. Lives in your Cowork account — activates whenever you ask to process invoices.
⏰
Monday 8am Scheduled Task
An automated task that runs every Monday morning, checks the invoice folder, runs your Skill on new files, and sends you a summary. No one needs to remember. No one needs to ask Claude. It just works.
👥
Collaboration Setup (optional)
CONTEXT.md, SESSION_LOG.md, DECISIONS.md in the shared folder + Project Instructions hook. Any teammate who mounts the same folder gets the same shared context — no briefing overhead, no confusion about what was decided.
🚀
Your next steps this week:
  • Use it on a real invoice — add an actual invoice PDF from your team to the folder and run the Skill. See how it handles real-world formatting.
  • Update after your first real-world test — there will be at least one edge case your Skill misses. That's expected. Add the rule and save again.
  • Share the project instructions — copy your Project Instructions into a doc and share with your team as "our AI rules." It's the fastest way to align everyone on standards.
  • Brief your tech team — show them the Scheduled Task and say: "When you connect the Google Drive Plugin, this runs on our live AP inbox automatically." That's the ask. They handle the plumbing.

Ready for the final activity? Design your next, bigger agent for a real process from your team.

🗺️ Go to Agent Design Canvas →

Generative & Agentic AI on AWS · Day 2: Build Your First Agent