A production-grade agentic AI workflow that automates job discovery, resume tailoring, quality review, and validation — running unattended on a nightly schedule. Built with Claude Code using a multi-agent architecture with a deterministic Python validation gate.

This project demonstrates practical AI agent orchestration skills by designing and operating a multi-agent automation pipeline for a real-world workflow.

Key capabilities demonstrated:

• Multi-agent AI system design and orchestration (Claude Code)
• Prompt engineering for specialized, role-scoped agents
• Deterministic quality gates with a zero-dependency Python validation script that catches AI hallucinations before output is used
• Unattended scheduled automation (Windows Task Scheduler + Claude Desktop)
• Human-in-the-loop design: AI drafts, validation gates check, human approves

Business outcome: A hands-off pipeline that discovers matching roles, tailors application documents against a single source of truth, and blocks fabricated or inconsistent content from ever reaching a recruiter by reducing hours of manual work per application to minutes of review.

🔗 Architecture Documentation | 💼 LinkedIn

Tailoring a resume for every job application is slow, repetitive, and error-prone. Worse, using AI naively for this task introduces a serious risk: large language models fabricate details - inventing metrics, inflating achievements, or introducing typos that propagate silently across every generated document.

This project solves both problems with an agentic workflow: specialized AI agents handle discovery, drafting, and review, while a deterministic (non-AI) validation script acts as a final quality gate before any document is approved for use.

Agentic AI Patterns:

• Multi-agent orchestration with specialized roles
• Separation of concerns (writer ≠ reviewer ≠ validator)
• Grounding: single source of truth (master resume) to prevent hallucination
• Deterministic validation of non-deterministic (LLM) output
• Human-in-the-loop approval workflow

Automation & Scripting:

• Zero-dependency Python validation tooling
• Unattended scheduled execution (Windows Task Scheduler)
• Structured data pipeline (Markdown source of truth + CSV role matrix)

                        ┌─────────────────────────────┐
                        │   Master Resume (Markdown)  │
                        │      single source of truth │
                        └──────────────┬──────────────┘
                                       │
  ┌──────────────┐   role matches   ┌──▼───────────────┐
  │  job-search  ├─────────────────►│  resume-writer   │
  │    agent     │                  │      agent       │
  └──────┬───────┘                  └──────┬───────────┘
         │                                 │ tailored draft
         │ updates                         ▼
  ┌──────▼───────────┐            ┌────────────────────┐
  │  Role-Fit CSV    │            │  resume-reviewer   │
  │  (24 roles)      │            │      agent         │
  └──────────────────┘            └──────┬─────────────┘
                                         │ reviewed draft
                                         ▼
                              ┌──────────────────────────┐
                              │  validate.py             │
                              │  deterministic gate      │
                              │  (zero dependencies)     │
                              └──────┬───────────────────┘
                                     │ PASS / FAIL report
                                     ▼
                              ┌──────────────────────────┐
                              │  Human review & approval │
                              └──────────────────────────┘

        ⏰ Scheduled nightly at 2:00 AM via Windows Task Scheduler
           (Claude Desktop, unattended run)

The most important lesson from this project: AI output cannot review itself. Early iterations produced two classes of silent failure:

1. Fabricated metrics — the writer agent invented plausible-sounding numbers that never existed in the source resume
2. Error propagation — a single misspelled employer name in one file propagated into every generated document

The fix was a zero-dependency Python validation script that runs before any document is approved:

• ✅ Cross-checks every metric/number in the output against the master resume
• ✅ Verifies employer names, dates, and titles against a canonical list
• ✅ Flags any content not traceable to the source of truth
• ✅ Binary pass/fail — a failed document never reaches the review stage

Design principle: LLM agents draft and review; deterministic code decides. This mirrors production AI system design, where guardrails are code, not prompts.

claude-agentic-job-search-pipeline/
├── agents/                  # Agent definitions (sanitized)
│   ├── job-search.md
│   ├── resume-writer.md
│   ├── resume-reviewer.md
│   └── README.md
├── validation/
│   └── validate.py          # Zero-dependency quality gate
├── data/
│   ├── master-resume.sample.md    # Sanitized sample
│   └── role-fit-matrix.sample.csv # Sanitized sample
├── scheduling/
│   └── task-scheduler-setup.md    # Unattended run configuration
├── docs/
│   └── architecture.md
└── README.md

Note: All personal data (real resume content, employer details, application history) has been removed. Sample files demonstrate structure only.

• ✅ Designed a 4-agent pipeline with strict separation of concerns
• ✅ Built a deterministic validation gate that eliminated AI-fabricated metrics from output
• ✅ Caught and fixed a silent error-propagation bug (misspelled employer name replicating across all outputs) — then added a validator rule so it can never recur
• ✅ Configured fully unattended nightly runs (2:00 AM) via Windows Task Scheduler
• ✅ Maintained a role-fit matrix covering 24 target roles as structured pipeline input
• ✅ Implemented human-in-the-loop approval — no document is sent without final human review

• ✅ Specialized agents produce more consistent output than one general prompt
• ✅ The reviewer catches issues the writer misses (independent review)
• ✅ Each agent's scope can be constrained (writer can't invent; reviewer can't edit)

• ✅ AI reviewing AI still hallucinates — deterministic code does not
• ✅ Zero dependencies = runs anywhere, no environment drift
• ✅ Binary pass/fail creates a hard gate, not a soft suggestion

• ✅ One source of truth prevents version drift
• ✅ Plain text = diffable, versionable in Git, and machine-verifiable

• Migrate scheduling to a cloud-native approach (AWS Lambda + EventBridge)
• Add application-tracking output (structured log of every submission)
• Extend the validator with configurable rule sets
• Notification integration (email/SNS summary after each nightly run)

This project demonstrates:

• ✅ Agentic AI workflow design and orchestration
• ✅ Prompt engineering with role constraints
• ✅ AI safety patterns: grounding, validation gates, human-in-the-loop
• ✅ Practical automation with scheduling and scripting
• ✅ Debugging distributed/multi-step AI systems

This project is licensed under the MIT License — see the LICENSE file for details.

Taofeek Adeyemi

Cloud Engineer & Technical Project Manager

• 🔗 LinkedIn: linkedin.com/in/taofeek-adeyemi
• 📧 Email: taofeekadeyemi22@gmail.com
• 🌐 Related project: AWS Serverless Marketplace

⭐ If you found this project interesting, please consider giving it a star!