Role
Team
Tools
Claude Code, Vercel, GitHub, Next.js, Miro
Timeline
Project Summary
Candid is an AI-powered audit tool that gives designers honest, structured feedback on their resume and portfolio, and checks that the two actually agree with each other. Built and shipped in one week using Claude and Claude Code, it isn't a Figma mockup or a prototype; it's a real, deployed product anyone can open and use today.
Phase 01
Where this Started
When I designed NBHD, one piece never made it past the concept stage: an AI assistant meant to help small businesses navigate their own branding and marketing, the kind of guidance most small teams can't afford to hire out for. The idea was sound, but a two-semester capstone timeline wasn't enough to build it. I sketched it, named her Nora, and moved on.
Nora didn't disappear. She reappeared, quietly, on the first page of my portfolio, a small assistant who introduces visitors to who I am as a designer before they scroll further. She never got to do the thing I originally imagined her for. She just said hello.
This project is that unfinished idea, picked back up. Not a rename, not a sequel, a different question asked of the same concept: what if I actually built the AI assistant NBHD never had time for, this time with an AI assistant of my own, and one week instead of two semesters? The result isn't Nora. It's Candid, an honest resume and portfolio audit for designers. But the throughline is real: an idea that couldn't be finished once got a second chance to exist, in a different shape, built differently, on a much shorter clock.
The Problem
I graduated from DAAP and started job hunting, and ran into the same wall most junior designers do: no easy access to real feedback on a resume or portfolio before it goes out the door. Career services queues are slow, mentors are busy, and most online tools only check one half of the equation, either the resume or the portfolio, never both. Nobody was checking whether the two actually told the same story.
Concept and Direction
I went through a few directions before landing on Candid. My first idea was a brand-consistency tool, too close in spirit to NBHD to feel like a new project. My second was a designer-matchmaking marketplace, connecting junior designers with mentors, but there was no realistic way to build something with real two-sided user data in a week without faking it. Candid won out because it solved my own actual problem, and because it had a feature no competitor in this space had: a "handshake" check that cross-references specific claims on a resume against the evidence actually sitting in the portfolio. Resume Worded, Grammarly, and Quillbot all grade one document. None of them ask whether the two documents agree.
Early Sketches
The four-tier severity system and the idea of quoting evidence back to the user both appeared here, before anything was built. Sign-in and accounts also appeared here, and were cut later in favor of storing nothing at all.
Design Principles
A few decisions shaped every screen in this app, made early and held to throughout.
No user accounts. Everything happens in-session, nothing is stored beyond the browser tab, and that's stated plainly to the user rather than buried in a policy page.
No fear-based copy. Early drafts of the findings language leaned toward "the ATS will reject this." I rewrote it to be honest about mechanism rather than threatening about outcome.
No auto-apply, job hosting, or AI rewrite tool. All were tempting scope additions I proposed and then cut myself, logged as future phases rather than built into week one.
Phase 02
Design Process
I designed and built this without Figma. NBHD was months of high-fidelity mockups; Candid was designed directly in code, iterated against a real, working build from day one instead of a static comp. Every screen, the category selection, the upload flow, the severity system, the score dimension cards, was shaped through actual use: I'd run a real audit, see what read as confusing or untrustworthy, and fix it immediately in the live app rather than in a separate design file.
The audit engine itself runs on a single structured call to Claude, tuned per design discipline, UX, UI, spatial, or motion, so the four dimensions it grades a resume or portfolio against actually fit the kind of work being reviewed, rather than applying one generic rubric to every designer.
Onboarding
Onboarding wasn't in the original plan. Testing the first working build made it obvious that dropping someone straight into an upload screen assumed they already knew what Candid was checking and why. A three-step walkthrough went in to set that up front. The back button came from the same round of testing, an early version only moved forward, which is fine for a demo and wrong for a person who mis-taps or wants to re-read a step. Both changes came from using the thing rather than designing it.
Building It For Real
The hardest and most interesting part of this sprint wasn't the interface, it was making the leap from a working prototype to something genuinely live on the internet. I used Claude Code as the bridge for that: porting the React prototype into a proper Next.js application, moving the API call server-side so the key powering the audit is never exposed to a visitor's browser, and walking through the full deployment pipeline, GitHub, Vercel, environment variables, a production timeout fix, end to end. That process was unfamiliar to me going in. Finishing it means Candid isn't a demo I can only show on my own laptop. It's a real URL, live right now, that works the same way for a stranger on their phone as it does for me.
Phase 03
Try Candid
A live, publicly deployed web application at candiddesign.vercel.app, built on Next.js with a server-side API route so no credentials are ever exposed to a visitor's browser, A full audit engine covering four design disciplines, UX, UI, spatial, and motion, each with tailored evaluation criteria, a public GitHub repository documenting the full build.
Reflection
The biggest shift this project made clear to me wasn't about Candid specifically, it was about what's actually possible for a single designer to ship alone now. A week ago, "build a real, working AI product" would have meant learning a backend framework, an API, a hosting pipeline, and a deployment process from scratch, on top of the actual design work. That gap used to be the whole reason design and engineering stayed separate disciplines. Working with Claude and Claude Code, that gap didn't disappear, but it got narrow enough for one person to cross it in a week without previously knowing how to code, and without pretending the result is fake or a prototype.
That's the part I want to be honest about, because it would be easy to overstate. AI didn't design Candid. It didn't decide that the consistency check was the differentiator worth building, or that fear-based copy was the wrong tone, or that a portfolio-only mode was needed so a single case study wouldn't unfairly fail the audit. Those were design decisions, made the same way any design decision gets made, by testing something, noticing it felt wrong, and fixing it. What AI did was remove the friction between having that judgment and acting on it immediately. When I noticed the upload screen was confusing, I didn't file it away for a later sprint, I fixed it in the same sitting. When I needed the app to actually exist on the internet instead of staying local on my laptop, that stopped being a multi-week engineering ask and became an afternoon's work I could walk through step by step.
So I don't think of this as AI replacing a skill I don't have. I think of it as removing a bottleneck that used to sit between a designer's judgment and a real, finished product. The judgment still has to be mine, an assistant that builds faster doesn't build better on its own. But the distance between having an idea and holding a working version of it in your hands got dramatically shorter this week, and I don't think that distance is going back to what it was.
Key Takeaways
Shipping means learning the whole pipeline, not just the build. Claude Code, React, Next.js, GitHub, Vercel, environment variables, all new to me this week. The hard part wasn't writing the app; it was everything between a working prototype and a URL a stranger can open. That gap used to be the reason design and engineering stayed separate. It's narrow enough now for one designer to cross it in a week.
Designing in code changes what you notice. Onboarding, the back button, the portfolio-only mode, none of those were planned. They came from running real audits and hitting the friction myself, which a static mockup can't surface. Building the real thing first meant the design decisions came from use rather than from guessing at use.
Saying no is what let it ship. A rewrite tool, cover letters, live re-scoring, user accounts, URL scanning, all were proposed, several by me, and all were cut. Every one of them was a good idea. Cutting them is the only reason there's a finished product instead of a half-built one with more features listed on a roadmap.
Next Steps
Three things I'd build next. Each was cut deliberately, not missed, and the last one matters most: a week can build the tool, but it can't prove the tool works.
