Building my Agentic Career OS

Summary

How I built my Agentic Career OS, the system of AI agents, scripts and notes behind my job search, and why the public job tracker is only the tip of the iceberg.

Comic strip in three panels. Oleg, smiling through a bead of sweat, has three redundancies in a row and asks what he wins, while his laptop shows a 0 with little fireworks. Two kids and two home renovations later, he’s exhausted at his laptop in a headset, job hunting the old way: copy, paste, repeat. He asks if it’s bedtime yet. The new way: Tally, the AI agent, reports roles found and records logged, and leaves the call to him. In sunglasses, he grins: this time, he’s brought an AI agent. The caption reads: difficult market requires better tools.

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 Triple Diamond Initiative Playbook v1 in heat and cold mode for the Agentic Career OS, with the statement: find the right next career step quickly. Idea 8 of 14, Problem 10 of 21, Solution 11 of 21 and Delivery 9 of 18 selected, all warm; Measure 1 of 11, cool.

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.

Excerpt from my discovery note of October 2026, in three parts. Risks, 5 of 23, each with its type, its mitigation and the risk left: interview questions are confidential; naming a recruiter or interviewer; private data leaking into the public data file; made-up facts in AI summaries; and the build eating the job search, marked the biggest. A trade-off: three smaller shapes for the page (stats only; public notes with a private board; a retrospective). Decisions, 2 of 13, each with the AI’s pick and my answer: on naming a company for bad behaviour the AI picked yes and I changed it to no name and shame; on where the code lives I took the default, inside the site.

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.

A chat between me and the AI from the design session in November 2026, in six messages. I ask for mock-ups and diagrams with clear context for a choice between options A and B. The AI replies that its pick is B, sample data online, with my real board only on my Mac until I say go, and sends a mock-up of both. I reply that sample data doesn’t make sense, and that maybe industry and job title should show instead of the company name, so the page is a curated copy of my Obsidian job board, with the stats and stories mattering most. The AI agrees, then asks two things with its pick on each: no company names anywhere (its pick: yes), and core title or full title (its pick: core). Two days later I answer: I agree, yes, and core will keep the names out for now. The AI says it is recording the two answers, updating the data contract and telling the website sessions, and will then start the exporter.

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.

Iceberg diagram: the public job tracker page above the water, shown by its share image inside the tip, one checked data file at the waterline, and three private layers below it feeding up: my notes in Obsidian, my candidate ATS, and the engine built with AI.

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: an architecture diagram of six parts, with a colour key (me, the AI, automation, my notes, the public side, outside). At the top, me: I decide, and say yes or no, with two arrows down to the Claude Code sessions, asks and yes or no. The sessions are orchestrator sessions, worker sessions and fresh sub-agents. Below them, side by side, are four parts. Skills, scripts and hooks (Markdown, Python and Claude Code), which the sessions run. My notes in Obsidian (Markdown and YAML records, views in Obsidian Bases, and the workflow map’s canvases), where the sessions write records, which I review. Integrations the sessions read from (the Ashby and Greenhouse job-board APIs, my email for replies and job alerts, and the Companies House API). And hosting and delivery, the public half (a JSON data file, a private GitHub repository, GitHub Actions checks, and AWS S3 and CloudFront hosting for daowolf.com/job-tracker), where the sessions run the exporter, then open a pull request after my yes.

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.

Diagram of my candidate ATS, from finding a role to an offer, redrawn from my workflow map’s overview. Seven numbered stages, each with its goal, who takes part (automation, the AI or me) and its step count. 1 Discover: roles worth reading reach me early, before the pile builds; automation, the AI and me (8 steps, 1 off). 2 Triage: read the real job description before any verdict; I decide; the AI and me (5 steps). 3 Log and track: every live thread is one record, and its fields are the tracker; automation, the AI and me (17 steps). 4 Apply: apply early, and warm wherever possible; automation, the AI and me (43 steps, 1 gap). 5 Wait and chase: know what’s alive, and chase what’s overdue; automation, the AI and me (16 steps). 6 Interview: show up with the right evidence, then bank what was learned; automation, the AI and me (20 steps, 1 gap, 1 planned). 7 Offer: decide on both lenses; the AI and me (6 steps, 1 gap). Then Offer accepted: I land the role. A dashed learning loop runs from stages 5, 6 and 7 back to Triage. Three side quests sit below: Tool shipped, close a gap the search exposed, determinism first; Post published, turn what the search teaches into public proof; and Connection made, build the warm routes that beat cold applications. Arrows link them: gaps the search exposes, from Discover to Tool shipped; stories and field signals, from Interview to Post published; write it up, from Tool shipped to Post published; inbound from content, from Post published to Connection made; and referrals and warm routes, from Connection made to Apply.

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.

Comic strip in three panels. Oleg smiles at a freshly drafted cover letter and says: letter’s ready, let’s have a read. Read back, the letter is a jumble of facts in mismatched sizes, and he says it reads like a ransom note. Tally, the AI agent, gives its best guess at the cause: it started from the job ad, then pulled in facts to fit. Oleg replies: facts to fit, not facts that fit. The caption says it happened more than once.

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
Stage 1, Discover, as a component diagram in the process diagram’s style. Its goal: roles worth reading reach me early, before the pile builds. 8 steps, 1 off. What starts it: I ask for new roles, which starts the board sweep (me); a daily sweep at 06:30, built but switched off, which would feed the fetch script directly (automation); and two that connect to nothing else on the picture: a job alert email arrives, and a recruiter or referrer brings a role. Components: the board sweep, a skill the AI runs, which sweeps Ashby and Greenhouse job boards plus my target companies; and the fetch script, a script that gives the same output for the same input, which fetches, normalises, snapshots and compares each board. It reads the Ashby and Greenhouse public job-board APIs. What it hands on: board snapshots, showing which postings are new, gone or changed, then the shortlist of new roles with title, place and freshness, which goes to stage 2, Triage. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 2, Triage, as a component diagram. Its goal: read the real job description before any verdict; I decide. 5 steps. What starts it: the shortlist from stage 1, Discover. A dashed learning loop brings what I learn in stages 5, 6 and 7 back into triage, drawn into my career strategy. Components: my career strategy, the source of truth for the two lenses, which the ranking uses; the AI reads the real job description and judges fit against my CV, and checks past contact in my records in Obsidian, my inbox and my old tracker, which is read only. What it hands on: the ranked shortlist, with fit in red, amber or green, a score on each lens and the one stretch to watch. I pick, park or skip, which goes to stage 3, Log and track, and I can stop following a company, so its roles no longer reach my shortlist. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 3, Log and track, as a component diagram. Its goal: every live thread is one record, and its fields are the tracker. 17 steps. What starts it: a new lead or application from stage 2, Triage, which starts the logging skill, and a company pack on request, which starts the research skill. Components: a read-only script lists what’s live from the records; the AI drafts the record, with both lenses, the fit map and a next action, and research sub-agents on request; the record scripts check each record’s fields, flag timing rows that disagree, and propose where each role came from and where I applied, writing them on my yes. For a company pack, research sub-agents gather rows of claim, exact quote and link, and the research script reads Companies House filings, fetches each page and checks every quote word for word, from company sites, filings and press; only the research script marks a row checked. What it hands on: I review each record (a new record is written first, then I review it; an update waits for my yes); the record and the tracker, one per opportunity in Obsidian, whose fields feed the tracker’s views, such as Focus and By channel, and which goes to stage 4, Apply; a session log entry, because status lives in the record, never in the AI’s memory; the memory check after it, which runs after each memory write and never fixes anything itself: a fix is a proposal for me; and the company pack of public facts, with a refresh date the script works out. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 4, Apply, as a component diagram. Its goal: apply early, and warm wherever possible. 43 steps, 1 gap. What starts it: from stage 3, Log and track, the AI checks whether the form wants a letter, and unless one is required I can apply now with my CV; tailoring the CV on request, a gap done ad hoc with no skill behind it; and a warm route, where I find one. Components: the letter writer drafts from the ad and my stories, polishing my words for the reader, and scripts check quotes and figures and list what they can’t check; a blind reviewer, a separate AI, reads each letter and flags what it finds, a finder and never the judge; my say: my reply to the story and the outline, a verdict on the letter, my word on the voice; the voice check measures longer drafts in my name against my own writing; the CV check reads the CV the way employers’ software might and scores it against the ad; the CV test tests one version of my CV against another, and a script names which to send; a note says which CV to use. Then I edit and submit the application, and a required letter waits for my verdict. What it hands on: my verdicts, logged, where every voice-check miss or false alarm turns into a permanent test; logging it, which marks it applied; and my records, the application’s record and my sourcing log, which go to stage 5, Wait and chase. The arrows show the form check leading to the letter writer, the letter writer going back and forth with the blind reviewer and with my say, the voice check feeding my say, my say leading to my verdicts, a dashed arrow from the CV tailoring to the voice check, the CV note feeding the CV check, the CV test and the submission, the CV test, the form check, the CV tailoring and the warm route all leading to the submission, and the submission being logged, then recorded. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 5, Wait and chase, as a component diagram. Its goal: know what’s alive, and chase what’s overdue. 16 steps. What starts it: from stage 4, Apply, a hiring system emails me an acknowledgement, a rejection or an invite, and filters in my inbox keep it in one place; the employer replies, or goes quiet; and the board check, a skill the AI runs when an application is logged, which never blocks it. Components: the inbox check, a skill the AI runs, makes read-only inbox searches on demand; the AI reads only what the script leaves unclear, from their subject and sender; the inbox check script, which gives the same output for the same input, skips what is logged, matches each email to its record and reads its subject, then a gate, and after a sweep it refreshes the note; the inbox sweep, a skill the AI runs, turns each email into a status update on its record and marks logged mail read, and the note feeds the sweep; and the posting check, a script, says whether each posting is listed, delisted or never seen, on Ashby and Greenhouse, and feeds the chase. What it hands on: the inbox check note, with what nobody has logged yet, any invites and one next action; my tracker’s views, with how long each application has been open, how long a reply takes and every next action due, and how overdue; and I chase overdue follow-ups. Then stage 6, Interview. What I learn goes back to stage 2, Triage. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 6, Interview, as a component diagram. Its goal: show up with the right evidence, then bank what was learned. 20 steps, 1 gap, 1 planned. What starts it: an interview invite, from stage 5, Wait and chase. Components: prep with the AI, a company deep-dive, likely questions and story bank answers, which is a gap done ad hoc with no skill behind it; worked system design boards, diagrams for software architecture interviews; mock interviews with CTO and peer personas, planned and not built; practice with the AI in a system design practice game, where I play, the AI coaches beside it and never scores me, and scripts check each challenge and keep the score; then the interview itself, which the prep notes, the mock interviews and the practice all feed; then my debrief, a skill the AI runs, where, after the interview, AI helpers mine stories I can reuse and analyse the round, and a script flags unsourced figures. What it hands on: prep notes; the employer’s decision, the next round or a decline; then stage 7, Offer; and what gets banked: my application notes, prep notes and story bank, updated. What I learn goes back to stage 2, Triage. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Stage 7, Offer, as a component diagram. Its goal: decide on both lenses. 6 steps, 1 gap. What starts it: an offer arrives, from stage 6, Interview. Components: the re-score, where the AI scores both lenses again on the real offer as it logs it; and I negotiate, a gap done ad hoc with no skill behind it. What it hands on: I accept or decline; my application record, with the outcome recorded; and the end: offer accepted, I land the role. What I learn goes back to stage 2, Triage. A second legend row says teal boxes are my notes, grey boxes are outside systems and people, and a dashed box is not built or switched off. 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.

Diagram, The Contract and The Governance, with what starts each step: automation, the AI, or me. The private half is at the bottom and the public half at the top, and the flow climbs between them. At the bottom, my records in Obsidian, with company names, people, pay and more, feed the exporter. It’s a Python script that checks all six contract rules and writes nothing if there’s any problem. The AI starts it. It writes one JSON data file, the only thing that crosses. It’s treated as public: what’s in it can show on the page. Beside the data file, the contract, a JSON Schema and six rules, sets its shape. Three of its rules: only agreed fields, with no company field. No exact dates, month or week only. No company, pay or person’s name. After my yes, the AI opens a pull request to the site build (Astro, Zod and TypeScript) at the top. GitHub Actions starts the build, and it checks the same contract rules, all but the one that needs my private lists. Then GitHub Actions puts the page at daowolf.com/job-tracker live, with no company names, people or pay. The governance, in a column under the page: my yes and a pull request, automatic checks on GitHub Actions, my typed go before it merges, then GitHub Actions puts it live and runs browser tests, and the AI checks the page.

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 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 application cards from the job tracker, each marked Rejected, with a job title, an industry, the month applied, the days to a first reply and the days to the rejection.

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.

Small workflow map, a side quest that runs within, and in parallel with, the main initiative: building the Agentic Career OS. Its steps sit under the playbook’s phases, in three lanes for me, the AI and automation. Idea: a gap or an idea (me). Discovery, understand the problem: discovery (the AI). Discovery, shape the solution: a short proposal (the AI), then I agree the shape before any code (me). Delivery: the AI builds the skill or script and updates the map, the map check and the tests must pass (automation), and the tool is shipped: one commit holds the change and the map’s update. Measure: a look at the map for gaps, what changed and anything missing (me), which loops back to the next idea.

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.

Comic strip in three panels: an application goes in and the kettle goes on; 6.5 hours later, three cups of tea in, a ‘no thanks’ arrives; Tally, the AI agent, logs the fastest rejection on record.

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.

Comic strip in three panels. A pull request note says the pre-commit hook passed, and Oleg is pleased. Tally, the AI agent, checks the proof and finds no output. Tally has found the cause: new working copies skip that check, so ‘passed’ meant ‘no proof’.

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.