Jonny Martyr
jobbity.
Jobhunting in the AI era
I used agentic design and development tools to build a personalised job hunting dashboard, allowing me to spend more time on the valuable parts of sourcing a new role whilst also exploring AI design and development techniques.
The Challenge
Job hunting has become a minefield. Job boards like LinkedIn and Glassdoor are incentivised to keep you on their sites, and so their searches often bury quality results in amongst dozens of irrelevant ones, creating a skinner box that keeps you scrolling and engaged. Job adverts themselves are becoming more and more complex, verbose and hyper-specific, necessitating more time from jobseekers simply to parse whether a job is relevant or not. At scale, this eats up hours of valuable time that could be better spent honing applications for quality roles.
I wanted to create a tool that would automate finding quality roles, reduce time spent on job boards, and free up time for working on the applications themselves.
Design
I planned to embrace an iterative design approach, so I began by building a basic job scraper that scanned multiple sites and presented results as a table. I used JobSpy as my scraper and created a basic layout using shadcn in Figma. I hooked this up to Copilot using Figma’s MCP and built out the first version of the app.
I was amazed at how quickly I was able to get this basic version of the app up and running – within hours I had a functional local dev build, and only needed to do some basic tweaks to get it feeling usable and aligned to the design system I had built in Figma.
Iteration
As I began using jobbity instead of going directly to job boards, two main workstreams started to emerge.
- Reliability. Could I trust that the results sourced by the JobSpy scraper were accurate, and that I wasn’t missing valuable roles? I ran multiple tests, building scripts to run regularly and test the integrity of results over time, and gradually tweaked and patched the scraper to balance absolute accuracy with speed and performance.
- Features. An important benefit of iterative design is that once you have built one layer, you can then stand on top of it to see what needs to come next. Once I’d built the basics the enhancements became clear, shortcutting what would have otherwise been a lengthy discovery and planning process. My Figma design system and MCP proved vital: If I needed a new control I could simply describe it to the agent, and reference the components I wanted to use. The result tended to be 80-90% accurate on the first attempt, necessitating only minimal tweaks. Copilot (and, later, Claude) were capable at filling in the blanks, and asked intelligent questions when prompted about edge cases and scenarios that I hadn’t considered.
Using the Figma MCP also became crucial to defining the design language of the app. I was able to create pixel-perfect designs in Figma, which were then replicated in code. I did a full pass of the design, replacing the temporary shadcn componentry, resulting in a fully branded and feature-rich experience.
At several points throughout this process I shared my progress on social media, gaining sizeable interest from others who wanted to try out the app themselves. I refactored the design and architecture to be powered by UI controls rather than background config, and began exploring how the app could technically be deployed (an ongoing challenge!).
Outcomes
Once I started using jobbity I was able to completely cut out LinkedIn and other job boards, saving me hours of fruitless scrolling and searching. With one click I could gather all the relevant, recent jobs and see at a glance which were relevant to me. By running my reliability tests I was able to trust the results I was seeing, and lean in to improving jobbity to further speed up my process.
I am now in the process of deploying jobbity as a consumer app, which requires some re-architecting of the underlying systems and introduction of auth and other user controls. As a UX designer, building a usable app alone would have been impossible only months ago, and so it has been an amazing and educational experience learning what is possible with agentic development.
Reflections
Whilst agentic development is undoubtedly revolutionary, it comes with some disadvantages that require mitigation. AI tools create a bias to action, which favours creation and iteration over planning. Just as constantly patching software leads to spaghetti code, iteration without planning can lead to “spaghetti design” – new features and functions crammed in where they fit, using newer patterns, inconsistent with existing UI. This can only be solved by potentially disruptive refactoring, or up-front planning to sketch out an outcome before putting pen to paper. Even in a simple app like jobbity, several refactors were necessary as the app grew and the hierarchy of controls became more complex.
To me, this demonstrates the ongoing value of design even as agentic tools become more common. Building and iterating is now lightning-fast, but establishing the right hierarchy, design systems, and user-centric practices up-front is even more important to keep the build process moving.