This post is written as a mentor guiding a mentee through the practical application of Agile Project Management concepts learned in the PDWD-APM-0226 course to a real-world project: the headhunter-agent.

Hey — you just completed the Agile Project Management module, and you’re looking at the headhunter-agent project going “how does this stuff actually apply?” Let’s walk through it together.

The course covered Scrum roles, events, artifacts, Kanban, estimation, continuous improvement, and Lean principles. The headhunter-agent is a Local-First Multi-Agent System (MAS) written in Clojure — a desktop GUI + CLI toolchain for job hunting automation. Let me show you how every Agile concept maps to something real in this codebase.

1. Scrum Roles — Who Does What on a Solo Project?

The course asks: What does a Scrum Master do to support teamwork and responsibility? On a solo project, you wear all three hats. But they’re still distinct responsibilities:

Architecture Diagram

On headhunter-agent, here’s how that breaks down:

Role Your Responsibility Headhunter-Agent Example
Product Owner Decide what to build next Prioritising M2M protocol P4 vs. adding a test suite
Scrum Master Remove blockers, keep process healthy Unblocking yourself when Gemini API rate-limits you
Developer Write code, test, deliver Implementing the 3-stage evaluator or the Daemon MCP server

The Scrum Master differs from a traditional Project Manager because you don’t command and control — you serve the team (which is yourself) by removing impediments. When you spend 3 hours debugging a DNS discovery issue, the SM in you asks: “What systemic fix prevents this from blocking next Sprint?”

2. Scrum Events — The Rhythm of Delivery

The course covers five Scrum events. Here’s how they map when you’re building the headhunter-agent:

Architecture Diagram

Sprint Length

A one-week Sprint works well for a solo project. The headhunter-agent has clear module boundaries — you can ship something meaningful each week:

Sprint Goal Deliverable
1 Data Vault extraction profiler.clj + data/master-profile.edn
2 Job evaluation pipeline evaluator.clj — 3 sequential Gemini agents
3 Interview prep interview.clj — STAR story mapping
4 PDF generation pdf.clj + Typst template integration
5 Application tracker tracker.clj — markdown pipeline
6 M2M key generation m2m/crypto.clj — Ed25519 identity
7 M2M discovery + fetch m2m/registry.clj + m2m/fetch.clj
8 M2M submit + verify m2m/submit.clj + m2m/verify.clj
9 Daemon MCP server daemon/core.clj + daemon/data.clj
10 Testing + hardening Test suite + CI pipeline

Sprint Planning

Ask: Given the current Product Backlog, what is the most valuable thing I can deliver this Sprint? For Sprint 9, the answer was the Daemon MCP server — because it unlocks MCP protocol integration.

Daily Scrum

Every morning answer three questions: - Yesterday: “Implemented tools/list and tools/call handlers for the Daemon” - Today: “Write the data content for all 9 tools, then wire up the HTTP server” - Blockers: “Need to figure out babashka http-server handler syntax” → unblocked by reading directory.clj

Sprint Review

At Sprint end, run the GUI and demo what you built. Record a screenshot or a short video. The review answers: Does this actually solve the problem?

Sprint Retrospective

The most important event for a solo developer. The course asks Why is continuous improvement important in Agile? Here’s why:

Architecture Diagram

3. Scrum Artifacts — Tracking Value Delivered

The course identifies three artifacts: Product Backlog, Sprint Backlog, Increment. The headhunter-agent already has a markdown-based tracker — let’s repurpose it as an Agile tool:

Architecture Diagram

Product Backlog

A living document of everything the headhunter-agent could become. Prioritised by value:

Architecture Diagram

The Definition of Done for a backlog item on headhunter-agent: - Code compiles without warnings - bb <command> runs without errors - D2 diagrams render correctly in the blog post - Commit message follows conventional commits format - README updated if behaviour changed

Sprint Backlog

During Sprint Planning, pull items from the Product Backlog into the Sprint Backlog. Track progress in data/applications.md:

# | Date | Sprint | Item | Status | Notes
1 | 24-Jun | Sprint 9 | Daemon core.clj | ✅ Done | 159 lines, MCP compliant
2 | 24-Jun | Sprint 9 | Daemon data.clj | ✅ Done | 283 lines, 9 tools
3 | 24-Jun | Sprint 9 | deps.edn alias | ✅ Done | :daemon alias added
4 | 24-Jun | Sprint 9 | Blog post | ✅ Done | D2 diagrams included

Increment

Every Sprint produces a potentially shippable Increment. For headhunter-agent, this means: - CLI commands work (bb daemon serve --port 8081) - GUI launches without JavaFX errors - D2 diagrams compile in the blog post build

4. Kanban vs Scrum — When to Use Which

The course asks: Compare Kanban and Scrum-based ceremonies. What is the purpose of each approach?

For headhunter-agent, you can use both:

Architecture Diagram

Scrum for Feature Development

Use Scrum when building a new module (like the Daemon). You need the structure of Sprints to stay focused.

Kanban for the Application Pipeline

The tracker (data/applications.md) is essentially a Kanban board for your job applications. Each application flows through states:

Architecture Diagram

5. Agile Estimation — Story Points and Velocity

The course asks: What are Agile estimation techniques, and how do they help in project planning?

For headhunter-agent, use Story Points with a modified Fibonacci sequence (1, 2, 3, 5, 8, 13):

Architecture Diagram

Velocity Tracking

Track your velocity over Sprints:

Architecture Diagram

If your average velocity is ~14 pts per Sprint, you know you can plan ~14 pts in Sprint Planning. No more overcommitting.

6. Sprint Burndown — Are You on Track?

A Sprint Burndown chart shows remaining work vs. time. For headhunter-agent, track it in the markdown tracker:

Architecture Diagram

If by Thursday you still have 8 pts remaining, you know you overcommitted. Next Sprint, plan fewer points.

7. Agile Ceremonies — Best Practices

The course asks: What are Agile ceremonies, and why are they important for team collaboration? List TWO best practices.

On a solo project, ceremonies are mental resets, not meetings. Here are the four ceremonies mapped:

Architecture Diagram

8. Lean Principles — Eliminating Waste

The course asks: How does the Lean principle of waste elimination support Agile continuous improvement?

In headhunter-agent development, waste takes many forms:

Architecture Diagram

Concrete example: The headhunter-agent already eliminates waste #6 (Delays) by being local-first — Gemini API calls are the only external dependency. The Daemon MCP server eliminates waste #3 (Relearning) by exposing system documentation through a standard protocol — any AI agent can query the architecture instead of you re-explaining it.

9. Continuous Improvement in Practice

The course asks: Why is continuous improvement important in Agile? Explain THREE key benefits.

Let me show you how three benefits play out in headhunter-agent:

Benefit 1: Enhanced Product Quality

Each retrospective identifies quality gaps. Sprint 8’s retro identified “no tests” as a critical gap. Sprint 9’s action item: “Write at least one test per day.” This directly improves the quality of the M2M crypto module.

Benefit 2: Increased Team Efficiency

The tracker.clj module went through three iterations: - Iteration 1: Manual markdown editing (wasteful) - Iteration 2: bb tracker add --company X CLI command (better) - Iteration 3: GUI tab with visual cards (efficient)

Each improvement came from a retrospective insight.

Benefit 3: Fostering Innovation

The Daemon MCP server was not in the original Product Backlog. It emerged from a Sprint Review where you realised: “I keep re-explaining the architecture to AI agents. What if the project could answer for itself?” That’s continuous improvement driving innovation.

Architecture Diagram

10. Putting It All Together — Your Sprint Template

Here’s a concrete template for running your next Sprint on headhunter-agent:

Architecture Diagram

Key Takeaways for Your Mentee

  1. Scales down, not up. All Scrum roles, events, and artifacts work for a solo developer. You just collapse the roles into one person and timebox the events aggressively.

  2. The tracker is your backlog. data/applications.md is already a Kanban board. Add a Sprint column and you have a complete Agile project management tool in markdown.

  3. D2 diagrams are your velocity chart. Every blog post documents a Sprint. The D2 diagrams serve as Sprint Review documentation — visual proof of what shipped.

  4. The Daemon is your retrospective output. The MCP server exists because you identified waste (#3 — relearning) and eliminated it by making the project self-documenting.

  5. Continuous improvement is real. Three Sprints ago, the headhunter-agent had no tests, no CI, and no Daemon. Now it has all three. That’s not magic — that’s one actionable change per retrospective, compounded.

Repository

The full source is at gitlab.com/nurazhar/headhunter-agent. The Product Backlog is whatever issue you open next. The Sprint starts when you decide to ship something. Go build.