
I’ve been here before. This is my third redundancy in 18 years, and my second in the last 4 years. In that time I’ve also managed to have 2 children and get 2 major home renovation projects done. Many factors and caveats contributed to the reality of my situation, and I believe the same goes for many other good folks out there who are looking for work.
The world isn’t exactly helping any of us: conflicts around the globe, cyber attacks, energy prices that keep rising, and an interest rate rise to go with them. It would be remiss of me to ignore the elephant in the room, AI, which is contributing to a lot of people’s circumstances across the job market. The dark side of capitalism at play here… but that’s a vent blog post for another day 💸
I did tell myself I would keep this blog focused on the fun and juicy part: how I built my Agentic Career OS, the system of AI agents, scripts and notes behind my job search: not just the public-facing static page but the whole thing.
So, without further ado, here it is…
🛠️ Building with AI and my Initiative Playbook
I took a relatively incremental but rapid thin-slice approach, iterating from idea to build multiple times.
I mapped the Agentic Career OS on my Triple Diamond Initiative Playbook, using the v1 tool on this site, to show the phase goals and activities it actually used. The tool’s point is to make the invisible visible, gaps included.
How to read the map 🗺️:
- The playbook splits an initiative into five phases: Idea, Discovery in two parts (understand the problem, then shape the solution), Delivery and Measure.
- Each phase has goals and activities to pick from.
- In heat and cold mode, the tool colours each phase by how many of its goals and activities I selected: warmer for more, cooler for fewer.

The Agentic Career OS, mapped on the Triple Diamond Initiative Playbook (v1).
Measure is the coolest phase: the one I’ve covered least, with 1 of its 11 selected, against about half or more in every other phase. That’s okay for now. It’s a conscious trade-off, and a gap I plan to close in the next iteration.
The rest of this post follows those phases, in order. In each one I say who did the work:
- AI assisted: I prompt and navigate, and the AI drives.
- AI: it acts by itself without my prompt, for example by picking a skill or a tool.
- Just me: no AI 🧠
One idea runs through all of it. If a script can do it, a script does it. The AI gets the parts that need judgement. And the calls are mine.
💡 Idea: from my old job tracker to something AI native
The Idea phase is about the why and the who. What did I want out of this, and who would do what between me, the AI and automation? This part was AI assisted: I discussed, brainstormed and iterated on it with the AI. The why goes back a few years.
Back in July 2023, I built my job tracker fully in a notes and database app for my previous job search. It helped me keep track of my applications, prep for interviews and take a bit of a data-driven approach to deciding where to invest my energy. I had ChatGPT doing some of the support, but mainly for research and a copy-and-paste approach. It still took quite a bit of time and effort to operate and maintain. Fast forward three years, and AI technology has evolved immensely. I’m now heavily using Claude Code to run orchestrator and worker agents (one lead AI session handing tasks to others) that do most of the heavy lifting. This gave me the idea to also evolve my existing job tracker workflow into something closer to being AI native.
The goal is finding the right next career step, quickly. Offloading as much of the search as I can is a byproduct of that goal and the solution I’ve designed. It means I can spend a bit more time on fun things like networking with other professionals, building projects, blogging about the exciting things I’m building (like this) and, most importantly, spending a bit more time with my kids 🎉
🔍 Discovery: the risks and decisions, before most of it got built
Next came discovery: understanding the opportunity.
Finding the right next career step, quickly, was the goal. But beyond that I wanted to build something from 0 to 1 that was relevant to me, but also to test out frontier model and harness capabilities (the newest AI models, and the tools and checks built around them). To build with AI, but also to build agentic systems, by placing agents where they are most effective. And hopefully to help others do the same.
The idea went through a six thinking hats review, a look from six set points of view. The risks, the trade-offs and the first decisions were written down before most of the Agentic Career OS got built. The review was AI assisted: I asked for it and the AI wrote it. Its three research passes were AI: it sent them out by itself. The decisions were AI assisted too: the AI set out the options, with its pick on most, and I took some picks and changed others.

From the discovery note the AI wrote for me: 5 of its 23 risks, one trade-off and 2 of the 13 decisions, as written. I’ve left out anything that names a company or a person.
Yes, we’re making a naughty or nice list. It’s nearly Christmas, after all. Nobody gets named though: naughty or nice, everyone gets the same thing, honest and constructive feedback. As they say, feedback is a gift 🎁
🧩 Discovery: designing the iceberg
With the opportunity clear, the next phase turned the proposal into a brief for a small first version. That meant the architecture, the security rules and how it would be tested. It was AI assisted: the AI drafted the brief, and my replies changed what the page shows.

From the design session: my reply to the AI’s mock-up, its two questions and my answer. My messages are as I sent them, ramblings and all: I use the mic a lot. The AI’s replies are cut down.
That exchange shaped one thing: what the public page shows. The whole system is far bigger, much of it was built before this brief, and it’s easiest to picture as an iceberg. The public job tracker page is only the tip, and three private layers sit under the water. The next three parts surface from the bottom: the engine, then my candidate ATS, then the waterline, where my notes meet the public page. The tip comes last, in Delivery.

The iceberg: one public page, one data file, three private layers.
🏗️ The engine: the architecture underneath
Start at the bottom of the iceberg, with the engine. Everything above it runs on these parts.

The engine: the parts, and what calls what.
Six parts do the work.
- Me. I make the calls.
- Claude Code sessions. Fresh sub-agents (separate AI helpers) do the reading, reviewing and fetching, without the conversation that produced the draft in front of them.
- Skills, scripts and hooks. A skill is a written procedure the AI follows. A script is ordinary code. It does the work that rules can settle, and it acts as a gate on what the AI produces: a check the output must pass. Hooks run checks by themselves after the AI edits a file, and when a session starts.
- My notes, in Obsidian. It links the notes into a graph, builds views from their fields, and shows a map of the whole workflow, which is the next part.
- Integrations. Public job-board APIs (the way programs read a site’s data) to find roles, my email for replies, and Companies House (the UK’s register of companies) for company facts.
- Hosting and delivery. The public half: a private site repository, continuous integration (checks that run by themselves on every change) and static hosting.
Two rules hold it together. If a script can do it, a script does it, and AI gets the parts that need judgement. And AI output never gets the last word: a script, a fresh AI reviewer that didn’t write it, or I check it.
🧪 Quality: tested along the way
That second rule is really about quality. For me, testing, checking and verification aren’t a phase at the end. They’re done incrementally, inside each phase and stage, as part of its activities. A six thinking hats review is a form of testing. So is a red team (a reviewer whose only job is to attack the work). Here’s what that looked like:
| Phase | What got tested | How |
|---|---|---|
| Discovery, the problem | The idea | A six thinking hats review, three research passes, and the risks and decisions written down |
| Discovery, the solution | The design | Mock-ups of both options, and a brief that covered the security rules and how it would be tested |
| The engine and the side quests | Each new tool | A proposal I agree before any code, then the tests and the map check have to pass |
| My candidate ATS | The AI’s output | Scripts as gates, a blind AI reviewer and a voice check |
| The waterline | The public data | The contract’s six rules, and tests that plant fake leaks |
| Delivery | The page | Automatic checks, two AI reviews, a fresh cross-check and my typed go |
| Measure | The live page | Five AI reviewers, one of them a red team, then a voice check on the new wording |
I also tested the testers. Before I trust an AI reviewer on my writing, I run it on texts where I already know the right answer. These are my evals (tests of the AI’s own judgement). One AI judge failed that test twice, so its verdict still doesn’t count. Two extra AI reviewers, one of them playing an English teacher, were tried on real letters and not kept. I measured how noisy the blind reviewer is: a flag it keeps comes back on an identical rerun about three times in four, on average. And each miss or false alarm I label on the voice check is kept as a test case: once the check gets it right, it has to stay right.
🔁 My candidate ATS: the process
One layer up is my candidate ATS: my own version of the applicant tracking system (ATS) that employers use. This is where the engine’s six parts and two rules get put to work on the search itself.

My candidate ATS: from finding a role to an offer, with the side quests around it.
This is an overview of my workflow map. That’s one file that models the whole search, and it’s the source of truth for who does what. The map borrows from two methods. Value stream mapping gives it stages that run left to right towards an offer. Event modelling gives each stage its triggers, actions and records. Each numbered stage shows its goal, who takes part (automation, the AI or me) and how many steps sit behind it. The dashed line is the learning loop, and the three boxes below are side quests. The model has had 55 versions since I first versioned it in October, nearly always when a tool was added or changed. The trade-offs are in it too: some steps stay manual, and one is built but switched off.
I’ve seen the sketches online where an AI interviews the interviewer, who is also an AI. That’s not what I’m doing here. I’m not trying to replace myself, and I don’t believe that’s the way to go. The AI does the heavy lifting, and the deciding, the submitting and the interviews stay with me. In a market where hardly anyone replies, this is about giving people some support and an advantage in landing a job.
If you ever do catch my AI interviewing your AI, something has gone wrong… 😶🌫️
Each stage has one design call worth knowing:
- Discover. A script collects and compares the job postings. The AI only judges how well each role fits.
- Triage. Fit is judged from the real job description, never from the job title, and the call is mine.
- Log & track. Where an application stands is written in its record, not in the AI’s memory.
- Apply. The points of a letter are agreed before it’s drafted, unless I skip that step. A second AI reads it blind and only flags: the verdict is mine.
- Wait & chase. The inbox check drafts nothing from an email nobody has checked, partly because an email can carry text written to steer an AI (prompt injection).
- Interview. The AI coaches me in practice but never scores me.
- Offer. The AI scores the role again on the real offer and leaves the decision to me.

From stage 4, Apply: why a letter’s points now get agreed before it’s drafted.
The strip above is a bit of a lesson learned. As a test, I let the AI produce a cover letter draft to see what it came back with. It came out like a ransom note. What I learned is that there are some things you don’t hand off completely. Talking it through and giving a raw draft is the way to go. So I use voice notes to talk a lot of it out, and that gets combined with everything else to produce the cover letter. Then I go through it, clean it up and update the things I want to update. I’m not trying to hand off the human elements, and they shouldn’t be handed off.
The full diagram for each stage, with its notes, is in the fold-out below.
Every stage in detail
Open full size Stage 1, Discover: how new roles reach me.
A script collects the job postings, compares them with the last sweep and filters them. The AI only judges how well each role fits and presents the shortlist to me. The daily sweep is built but stays off until I say so. And if the script can’t find a job posting on a company’s board, it doesn’t assume the role has closed. It only suggests that when it saw the posting there before and now it’s gone.
Open full size Stage 2, Triage: the real job description gets read before any verdict, and I decide.
The script’s ranking only tells the AI which roles to read first. It isn’t a verdict. The AI judges fit from the real job description, never from the job title. Each role is looked at through two lenses: what it does for my life now, and what it builds for the future. If a role has a hard requirement I don’t meet, it’s a skip. If the question is whether I’ve managed at enough depth, that call stays with me.
Open full size Stage 3, Log & track: one record per live thread, and the records are the tracker.
Where an application stands is written in its record, not in the AI’s memory. When the AI asked whether its memory should keep its own copy, I replied that this should be in Obsidian. A copy in memory goes out of date. Each live record also carries a next action. The fit map, which sets the job’s requirements against my evidence, comes only when I have the job description. The last check that a record has the right fields in the right format is a script, not the AI reading it through. My rule: I prefer a deterministic approach (the same input always gives the same answer), with a schema (a fixed list of fields) as guardrails, but only where it adds value.
Open full size Stage 4, Apply: the letter, the CV, and the submit that stays with me.
A note tells me which CV to use, and a letter nobody asked for doesn’t get written. More than once I noticed a disjointed letter that threw garbled facts together. The AI’s own diagnosis: it had started from the job ad and pulled in facts to fit. Now the points are agreed first, and each sentence either points to something in my record or says it’s the AI’s wording. A second AI reads each letter blind. It’s good at spotting problems and bad at judging them, so it only flags and the verdict is mine. The CV score shows how the CV compares before and after an edit. It’s never a pass mark.
Open full size Stage 5, Wait & chase: what’s alive, and what’s overdue.
The inbox check only tells me which emails haven’t been logged. It doesn’t draft the record updates, because they’d be written from emails nobody has checked, and an email can carry text written to steer an AI. A status only ever moves forward, to the furthest stage an application reached, and the outcome is kept beside it. That lets me count where applications drop off and how long things take. For now the posting check covers only Ashby and Greenhouse boards, and a view lists every next action that’s due.
Open full size Stage 6, Interview: prep before, a debrief after.
Before an interview I get prep notes and, when I ask, worked system design boards (diagrams for software architecture interviews). In the practice game the AI coaches me but never scores me, so the score stays out of an AI’s hands. A script checks new notes for figures with no source. For now it only flags them and doesn’t stop the note saving, because that could hold up a prep note an hour before a call. The prep itself is still done as needed, with no tool behind it, and mock interviews aren’t built.
Open full size Stage 7, Offer: an offer gets scored on both lenses again, and I decide.
A score made before I know the full job description or the pay is marked as provisional until those facts arrive. When an offer comes, the AI scores both lenses again on the real offer. It puts the offer at the top of its summary and leaves the decision to me. Negotiating has no tool behind it: I do that myself.
🌊 The waterline: from my Obsidian notes to the public page
Next up the iceberg are my notes, and the waterline where they meet the public page.
The tracker has two halves joined by a contract: an agreed list of what data may cross between them, and in what shape. The private half is my notes: one record per application in Markdown and YAML (plain text, with labelled fields at the top), holding company names, people, pay and more. The public half is a static page with sensitive data redacted.

The contract and the governance (checks and balances) between the two halves.
A script, the exporter, turns each record into a card: a core job title (without the team or place), an industry, the month I applied and some day counts. Here’s a real one from the data file the page is built from. It’s in JSON, a common text format for data:
{
"id": "ry3iwnqt",
"state": "closed",
"title": "Engineering Manager",
"industry": "financial-services",
"level": "engineering-manager",
"work_mode": "hybrid",
"applied_month": "2026-10",
"stage_reached": "applied",
"outcome": "rejected",
"days_to_first_reply": 1,
"days_to_outcome": 1,
"no_reply_days": null,
"story": null
}
The AI proposes an industry for each new company and drafts the weekly note, and both wait for my approval. Every stat is computed by the script, never typed. My fastest rejection, 6.5 hours, is worked out from the send times of two emails: the automatic “application received” one and the rejection. Just the number of hours goes into the data file, and the times themselves stay in my private notes.
Then a leak check reads every field that holds free text, such as job titles and the weekly notes. It’s part of the exporter, so it’s ordinary code, not an AI. It catches a company from any of my records, and any leak it finds stops the export. Every card gets a random id, like ry3iwnqt in the example above. More than once, a new application didn’t have one yet, so the export stopped:
🔴 1 problem(s); nothing written:
- '[application name hidden]': no card id yet (run with --propose)
The check has to give the same answer every time, and tests check its answers. The tests plant fake leaks to show that the check catches them. The AI can miss things or make them up, so it never has the final say on what goes public. Today the AI starts the export when I ask, by following a skill (a written procedure).
The contract is a short document with a JSON schema (a list of the exact fields the data file may hold, and what each may contain) and six rules. The exporter checks all six before it writes. The site checks five of them again when it builds. The other one, no company, pay or person’s name, needs my private lists, so only the exporter runs it. Changing the file’s fields takes a new contract version: the change is agreed first, the version number goes up, and the exporter and the site update their checks in the same week. It’s on version 3 now.
The page is built when the site is built, not in the browser. A strict schema refuses any field name it doesn’t know and any currency sign, and if a headline total disagrees with the cards, the build fails. New data goes out as a pull request (a proposed change that waits for review), and the rule is that it merges only after my own typed go. The AI’s standing instructions say the same: ask me before anything goes public.
🚀 Delivery: building it and going live
Then came the build, and the same gates for every release: passing checks and my typed go before any merge, then a deploy, then tests against the live site. The page itself went public on 5 November, once its checks had passed. Who did what:
| Part | Who | How |
|---|---|---|
| The exporter, its leak-check and the page’s look | AI assisted | I steered, and the look took three design rounds |
| The hand-offs for the page | AI | An orchestrator briefed a worker session by itself and passed my notes on, and the worker wrote the version that launched |
| The tests, the deploy and the live check | Automation | The site’s existing automation ran them |
| The go | Just me | My typed go, before any merge |
Every release takes the same route:
- Export. I ask, and the AI runs the exporter. It writes the data file only if every rule of the contract passes.
- Pull request. After my yes, the AI opens a pull request with the new data file.
- Checks. GitHub Actions builds the site and runs the checks. The build repeats the contract’s rules, all but the one that needs my private lists.
- My go. Nothing merges until I’ve typed my go.
- Deploy. GitHub Actions puts the site live.
- Live check. Browser tests run against the live site, and the AI checks the page itself.
🧊 The tip: the public page
And this is what all of that delivers: the tip of the iceberg, the one part anyone can see. You can find my public-facing job tracker on this site.
I built it to shine a light on the reality of my current job hunting situation through the data.
The page shows where my applications stand: how many I’ve sent, how far they got, how long replies take, and which ones went quiet. Each application is a card with a job title, an industry and a month, never a company. That’s a choice. I can back things up, because my Agentic Career OS tracks pretty much everything, but the stats and the lessons matter more than who said what. A short note says what changed that week.

Three cards from the live job tracker, 16 Nov 2026.
All of that comes from one data file.
🧱 Side quests: how each tool got built
Underneath the main build, every tool was a side quest of its own. When the search exposed a gap, the fix went through the same playbook cycle in miniature: an idea, a short discovery, a proposal I agree before any code, the build, and a look back at the map. I built the skills, scripts and gates with AI coding agents, mostly Claude Code, and each one ends in a commit (one saved step in the project’s history) that holds the change and the map’s update together.

A side quest on the same playbook. The Initiative Playbook acts as a mental model: it can be as simple or as complex as the situation calls for.
The workflow map keeps the build honest. A check runs against it after every AI edit to a skill, and at the start of every session: a new script that isn’t on the map fails it, a changed skill has to be reviewed again, and the map’s own diagrams redraw themselves.
📏 Measure: the lessons, and what’s next
Measure is where I’ve done the least, as the playbook map at the top shows. What I do measure is the search itself. The job tracker tracks how many applications I send and how far each one gets, and I review it every so often. What I have beyond that is the learning: each lesson below ends in a change or a rule, though two of the rules are still proposals. Who caught what is a mix. Several began with a question I asked (just me). Others came from fresh AI readers, checking at my request (AI assisted). One an AI worker found by itself (AI).
📚 Refine: what building it taught me
The lessons come from where AI sits and is best utilised, and how you have to build your harness around it. They also come from the results and output of the prompts and the things you’re building, always tweaking.
A label claimed more than the data held. The page first called a figure “Human replies”. I asked how we knew a reply was human, and we didn’t: the count included rejections sent from a template. I caught it, not the AIs that built it or either review. Now the page counts a reply “even if it was a standard rejection”. The rule: trace how a value is made before a label claims it.
“Same day” became 6.5 hours. At first the page said my fastest rejection came the “same day”, because it only counted whole days. I asked for a number, and a script timed both emails at 6 hours 27 minutes. The change: the page now gives the number.

From the “Fastest rejection” card on my job tracker.
Tests passed while the page was wrong. On launch evening, the tests, two AI reviews and the checks on a preview copy of the site all passed. The flow chart still called a live application “stopped”, and a fresh reader given only the files found it. The rule: before go-live, every number and claim gets one fresh cross-check.
A check that never ran. An AI worker reported that a pre-commit check (one that runs before each change is saved) had passed. It hadn’t run: that hook silently skips new working copies (fresh copies of the project). The rule I’ve proposed: a check counts as evidence only if its output was captured.

From the build: the check that never ran.
A few more, in one line each:
- Five reviewers, one of them a red team: then a voice check, and my own edits afterwards set two rules. If a reviewer wants to change a line I wrote, my version wins, and a bit of friendly humour stays.
- Checks cost something too: three fresh agents once re-checked a file identical to one already checked, for about 306,000 tokens (the units that AI usage is measured in). The rule I’ve proposed: match the check to what could actually differ.
- The AI described the workflow from the code: it missed the logging stage and its own part in preparing the public page. Now it reads my workflow map first.
Look back over the whole system: the AI reads messy email, drafts words and starts the scripts, but the numbers are computed by scripts. Scripts do the work that has one right answer, and I make the calls. One gap is left in how dates get into the records, and it’s on my list.
🔭 Iterate: what’s next
- The next step is to find which parts of the workflow I can build into n8n (a workflow automation tool), and probably plug in smaller AI models to help. Small models already do some narrow jobs elsewhere in my set-up.
- I want to see where I can secure things like reading emails, and possibly work out a secure model for that. At the moment, the AI still reads some job emails when it logs them.
- And I want to pull out the reasons in the emails and the feedback I get, which comes few and far between. That would feed back into things like how I can improve my CV, and maybe even target the jobs I apply for. Whether a person or a template wrote each reply, and how many interview rounds there were, aren’t in the data yet.
- I also want to do more with hooks in the AI tool. A hook could run the leak check on many different events, such as when the AI edits a record.
- I’d also like to build out the competency-based framework I’ve used for personal development plans before. I’d map my competencies against my CVs and each job description, and have the AI tailor the CV from that mapping. Any gaps that appear would get triaged: can I close them, or how do I address them?
- I’d like to make the measuring more active. Maybe I’ll turn some of what the job tracker shows into targets, and maybe even SLOs (service level objectives, the targets a system is held to) somewhere. We’ll see.
🏁 That’s a wrap
When I started this post, my first thought was simple: I’ll just talk about the public page and how I built it. But as I wrote down how it was built and what it went through, I was amazed by the depth. The iceberg came along because I rediscovered how much complexity sits under that one page.
That tells its own story about building with AI. AI can create a level of abstraction that hides some of the complexity, so you don’t realise how quickly you’ve built a relatively complex system. That makes it even more important, when you’re building with AI or building AI into your workflows, to have a method with guardrails and governance in place, for a system you keep evolving in so many directions.
For me, that method is my Triple Diamond Initiative Playbook. Using it, explicitly or implicitly, has kept the whole system on track. It’s a self-learning, evolving mechanism that I built quite early on, and it gives me the confidence to keep evolving the system across different AI-assisted conversations without too much stress.
It goes beyond this Agentic Career OS too. I’m building another tool in public, AI HC2: a local command centre for seeing and steering the AI harnesses on my machine (the tools that run AI agents). It’s early, pre-alpha, and it’s there to help me govern my AI work. My orchestrators use the Initiative Playbook as well, so they all follow similar patterns, with similar guardrails and governance. That lets me build, iterate through designs and ship quickly, with more confidence.
And that brings me back to where I started. I’ve been here before, but this time it feels different. I’m spending a lot of time building this, but it isn’t taking up as much cognitive load as I remember from my last redundancy. The stress is still there. But I can switch off and spend time with my kids, because I know that behind the scenes some of this is doing the work for me. It isn’t idle, and progress is being made. When I come back, I review, sign things off and keep going. Ideally, the next stage is to make it a little more autonomous. Already it gives me time back: for my kids, for building things, and even for writing this post. Last time I was made redundant, I couldn’t find the time to blog that easily.
I hope this is an opportunity and a lesson for others: build your own things in a safe, responsible way, learn from them, and apply a similar playbook or approach. For me, a good measure of success off the back of this post would be people reaching out, connecting, sharing and learning. Who knows, maybe it even lands me a job. Ideally it helps other people too, with what they’re going through and what they’re building. If you’re interested, reach out to me on LinkedIn, or book an exploratory chat. I’m available for hire, for limited time only!
The tracker is at daowolf.com/job-tracker, and I’m going to update it weekly.