How procurement teams use AI in real purchasing work

You are a developer building a 'supplier research' automation for a procurement department.

Goal: create /src/procurement/sourceSuppliers.ts.
Input: {
  productCategory: string,
  region: string ('Europe', 'Asia', 'Turkey'…),
  certifications: string[] (e.g. ['GMP', 'ISO 22716']),
  maxMoq: number,
  targetPriceRange: [min, max, currency]
}

Flow:
1. Perplexity Sonar API structured search: region + category + certifications.
2. For each firm returned, extra scraping (HTTP request): if it has a site, fetch 'about', 'certifications', 'contact'.
3. Certification verification: query GMP/ECOCERT/COSMOS registries by company name + country.
4. Send everything to Anthropic Claude Sonnet, structured output:
   {
     name, location, estimated_revenue, certifications: { cert, verified: bool }[],
     moq_range, price_indication, lead_time_days, score_0_100, score_reasoning,
     risk_flags: string[], sources: { type, url }[]
   }
5. Write to Notion 'Supplier Candidates' database via writeNotion.ts.
6. Notify Slack: 'Found X firms, top 3 are…'

Notion property types: Name (title), Score (number), MOQ (number), Price (rich_text), Certifications (multi_select), Verified (checkbox), Risk Flags (multi_select), Sources (rich_text), Status (status: 'New' | 'Reviewing' | 'Rejected' | 'Approved').

Show the plan first.

You are a developer building RFQ automation for a procurement team.

Goal: 3 files under /src/rfq/.

1. createRfqEmail.ts — input: { productSpec, commercialTerms, supplierName, contactPerson, language }
   Output: { subject, body, attachmentTechnicalSpec.pdf }
   Tone tailored to the firm and language via Anthropic Claude Sonnet. Tech spec goes as a separate PDF.

2. sendRfqBatch.ts — input: supplier list [{ name, email, contact, language }]
   For each supplier call createRfqEmail; send via Gmail API.
   Write to Postgres 'rfq_threads': rfq_id, supplier_id, sent_at, message_id, status='sent'.

3. parseQuoteReply.ts — input: incoming email (IMAP trigger).
   If message_id is a reply to our rfq_thread:
   - Send the PDF/inline text to Claude Sonnet, structured output:
     { unit_price, currency, moq, lead_time_days, payment_terms, validity_days,
       warranty, incoterm, notes, missing_fields: string[] }
   - Add a row to Google Sheets 'rfq_<id>_comparison'.
   - If missing_fields, draft an automatic follow-up email (human approves in Slack).

Plus a comparison view: /src/rfq/compareQuotes.ts —
input: rfq_id, output: top 3 suppliers + reasoning (weighted score: price + delivery + payment).

Plan first, then code.

You are a developer building a contract analysis tool for a company's legal + procurement teams.

Goal: /src/contracts/analyzeContract.ts

Flow:
1. Input: PDF file path or URL.
2. Extract text with pdf-parse; clean it (drop page numbers, footers).
3. Chunk with Document Loader (chunk_size: 4000 tokens, overlap: 400 — clauses shouldn't cross boundaries).
4. Send each chunk to Anthropic Claude Sonnet, structured output:
   {
     clauses_found: [{ clause_number, type, text_excerpt, risk_level: 'low'|'med'|'high', notes }],
     pricing_triggers: [{ description, index_used, frequency, cap }],
     termination_terms: { mutual, fault, convenience, notice_days },
     penalties: [{ type, amount, cap, applies_to }],
     missing_clauses_expected: string[]
   }
5. Merge all chunk outputs into one final report (executive summary + per-chunk summary).
6. Compare mode: --compare-with <prev_contract_id> → diff the clauses (changed, added, removed).
7. Save to Postgres 'contract_analyses' (contract_hash, supplier, analysis_json, created_at).
8. Create a new Notion page 'Contract Analysis - <Supplier> - <Date>' with all sections in markdown.
9. Notify Slack: '<Supplier> contract analysed — X risks found, Y negotiation priorities.'

Audit: every analysis writes to 'audit_log' (who ran, when, which contract). For GDPR/SOX.

Plan first.

You are a developer building a 'spend analysis' automation tool for procurement management.

Goal: /src/spend/monthlyReport.ts

Flow:
1. Schedule trigger: runs on the 1st of every month.
2. Data sources (parametric):
   - Postgres 'purchase_orders' table (if ERP syncs to it), OR
   - Excel/CSV files (from a Drive folder).
3. Aggregation in TypeScript (danfo.js or simple reduce):
   - Total spend by category (last_30_days, last_90_days, last_365_days)
   - Total by supplier + supplier concentration score (Herfindahl index)
   - Same-item price comparison across suppliers (anomaly_score)
   - Month-over-month % change
4. Send the aggregated data to Anthropic Claude Sonnet, structured output:
   {
     executive_summary: string (3 paragraphs),
     top_categories: [{ name, total, share_pct, trend }],
     supplier_concentration: { top5_share, risk_level, recommendation },
     anomalies: [{ description, financial_impact, suggested_action }],
     savings_opportunities: [{ idea, est_savings_pct, est_savings_amount, effort, priority }]
   }
5. Render a PDF report (pdfkit or headless Chrome HTML→PDF), upload to Drive.
6. Write each savings_opportunity as a new 'New' status row in a Notion 'Spend Actions' database.
7. Notify Slack: 'Monthly report ready — $X in savings opportunities identified.'

Don't send raw data anonymously: mask or shorten supplier names if you're not on an enterprise LLM plan.

Plan first.

You are a developer building demand-forecasting automation for a procurement team.

Goal: /src/demand/forecast.ts (TypeScript) + /scripts/run_forecast.py (Python).

Flow:
1. /scripts/run_forecast.py — pull last 24 months from Postgres 'orders' (sku, month, qty).
   For each SKU run Facebook Prophet, forecast 12 months.
   Output /tmp/forecast.json — { sku, monthly_forecast: [{ month, yhat, yhat_lower, yhat_upper }] }.

2. /src/demand/forecast.ts:
   - Run the Python script via child_process (await execFile).
   - Read forecast.json.
   - Send to Anthropic Claude Sonnet with context { market_growth_pct, expected_new_clients, sector_seasonality_notes }.
   - Structured output:
     {
       sku_recommendations: [{
         sku, order_calendar: [{ month, order_qty, reasoning, supplier_capacity_alert }]
       }],
       executive_summary: string,
       risks: string[]
     }
3. Notion API:
   - For each SKU, a new row + chart in 'Demand Forecast' database.
   - 'Order Calendar' calendar view for the visual.
4. Supplier capacity warning drafts:
   - If order_calendar shows a month with qty > 150% of supplier's 12-month average:
   - Have Claude draft a courteous capacity-warning email to that supplier.
   - Post the drafts to Slack for approval.

Plan first.

You are a developer building a 'daily writing assistant' for a procurement department.

Goal: /src/comms/ folder.

Components:
1. /src/comms/templates.ts — 5 email templates:
   - REJECT_OFFER (decline + revise request)
   - PRICE_NEGOTIATION
   - ORDER_CONFIRMATION (confirm + logistics)
   - LATE_DELIVERY_FOLLOWUP
   - MEETING_SUMMARY (post-meeting recap)
   Each: trigger prompt + structured input + Claude system prompt.

2. /src/comms/brandVoice.md — the company brand voice doc:
   - Tonal rules (formality, warmth)
   - Words to never use ('impossible', 'never')
   - Preferred sign-offs (Best regards / Kind regards)
   - 2 example emails pasted in (style examples)

3. /src/comms/draftEmail.ts — input: { type, context }, output: { subject, body, tone_check }
   Pass brand voice + template + context to Claude Sonnet, get a draft.
   Each output has tone_check: '0-100 brand-voice fit score.'

4. /src/comms/slackBot.ts — Slack slash commands:
   /negotiate @supplier vol:5M item:'PET preform' price:0.085 target:0.077
   → call draftEmail, post the draft to Slack DM.
   If the user clicks 'Approve' → save as Gmail draft.

5. /src/comms/meetingSummary.ts — input: audio transcript (from Whisper), output:
   { summary, decisions, action_items: [{owner, task, deadline}], next_meeting_date }
   Call Asana API to create each action_item as a task.

Plan first.