The current tech job market is competitive. One piece of advice I’ve consistently heard is that being thoughtful and intentional in a job search matters more than sending out hundreds of applications.
The “spray and pray” model doesn’t work very well anymore.
While listening to a podcast by Danny Thompson and Leon Noel, they emphasized that engineers should approach the job search process strategically. One recommendation they made was simple but powerful:
Track your job search process.
Use a spreadsheet.
Document outreach.
Follow up intentionally.
Be deliberate.
Google Sheets is intuitive, flexible, and surprisingly powerful for this kind of workflow.
That idea stuck with me.
At the same time, I’ve been exploring how modern AI systems can interact with external tools using MCP (Model Context Protocol). I’ve been using MCP at work to access internal documentation through tools like Confluence and Slack, and I started to see how powerful it could be as an interface layer between AI and real systems.
That led to a question:
What if I could incorporate LLMs directly into the job search workflow?
Instead of manually filling out spreadsheets, could natural language become the interface?
For example:
“I applied to Stripe yesterday for a backend role. Recruiter Jane Smith. Follow up next week.”
And have that automatically converted into structured tracking data.
That became the foundation for this project.
The idea
I wanted to build something practical, not theoretical.
I didn’t want another demo that generated text.
I wanted to build something that:
solves a real problem
improves a real workflow
teaches modern AI patterns
could realistically be extended into a product
Previously, I had been using ChatGPT’s project feature to keep track of roles I was interested in. That worked, but the data wasn’t structured, and it wasn’t easy to query or track follow-ups over time.
A spreadsheet felt like the right balance of simplicity and flexibility.
So I built a small system that converts natural language into structured job-tracking data.
How it works
The system uses a multi-agent workflow:
Agent 1 extracts structured job information from natural language.
Agent 2 checks for duplicates to prevent accidental repeat applications.
The structured data is then written to Google Sheets.
MCP exposes the system’s tools so that AI assistants like Claude can call them directly.
The workflow looks like this:
Natural language input
↓
LLM structured extraction
↓
duplicate detection
↓
Google Sheets update
↓
AI assistant returns insight
Example:
“I applied to Anthropic for an AI Safety Engineer role. Recruiter Amy Steels. Follow up April 29.”
The system extracts:
Company
Role
Date applied
Recruiter contact
Follow-up timing
and appends the row to the job tracker.
Claude can then reason over the stored data and surface useful insights like:
“You have follow-ups due this week.”
Why this project was interesting
I wanted to better understand:
multi-agent patterns
MCP architecture
How AI tools call external systems
How to design structured extraction pipelines
One challenge was that MCP is still relatively new.
There aren’t many established patterns yet.
You can’t simply vibe-code something like this and expect it to work reliably.
I had to think carefully about:
How the system should flow
How agents should be separated
How tools should be exposed
How structured data should be validated
How the environment configuration should be handled
The most satisfying moment was when Claude successfully updated the spreadsheet automatically.
That was the moment when the system felt real.
Perspective on AI
I see AI as a productivity multiplier and a new layer of engineering.
The most interesting shift is not that AI replaces engineers.
It expands what is possible.
It encourages more systems thinking.
It pushes you to think about interfaces between human language and structured systems.
It also rewards imagination.
Instead of asking:
“How do I implement this feature?”
We increasingly ask:
“What workflows should exist?”
Who this is useful for
Anyone going through a job search can benefit from being more intentional.
Tracking:
applications
recruiter conversations
referrals
follow-ups
can make a meaningful difference.
Even a simple organization can reduce stress and improve consistency.
This project explores how AI can make that process easier without adding complexity.
Why is MCP interesting
MCP allows AI systems to interact with tools in a structured way.
Instead of AI generating text and stopping there, it can:
read structured data
update records
reason about timelines
coordinate workflows
This opens the door to more practical AI applications.
AI becomes part of the software architecture, not just an add-on feature.
Future directions
This pattern can extend beyond job searching.
Similar workflows could support:
CRM tracking
sales pipelines
research tracking
project documentation
meeting notes
follow-up reminders
The core idea is simple:
Natural language becomes a structured state.
From there, systems can reason over the data and assist more effectively.
Final thoughts
Building this project reinforced something I’ve been learning:
AI works best when combined with thoughtful system design.
LLMs are powerful, but structure makes them reliable.
I’m excited to keep exploring how these patterns evolve.
Leave a Reply