<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.4.1">Jekyll</generator><link href="https://tejalgoyal2.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://tejalgoyal2.github.io/" rel="alternate" type="text/html" /><updated>2026-06-10T21:40:49+00:00</updated><id>https://tejalgoyal2.github.io/feed.xml</id><title type="html">Tejal’s Blog</title><subtitle>Building in public — dev projects, vibe coding, and things I&apos;m learning along the way.</subtitle><author><name>Tejal Goyal</name></author><entry><title type="html">Building tgoyal.me With Claude: The Full Guide, Every Prompt Included</title><link href="https://tejalgoyal2.github.io/posts/2026/06/08/portfolio-revamp-full-guide/" rel="alternate" type="text/html" title="Building tgoyal.me With Claude: The Full Guide, Every Prompt Included" /><published>2026-06-08T00:00:00+00:00</published><updated>2026-06-08T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/06/08/portfolio-revamp-full-guide</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/06/08/portfolio-revamp-full-guide/"><![CDATA[<p>The first time I gave Claude total creative freedom over my portfolio, it produced the most average website I have ever seen. The second time, I handed it three reference sites I genuinely love and it ignored all of them. The third attempt became <a href="https://tgoyal.me">tgoyal.me</a>, and the difference between the three attempts is the entire point of this post.</p>

<p>This is the real story with the real prompts, typos and meltdowns included, because that is the most useful thing I can hand you. Anyone can tell you what to build. Fewer people show you how they actually talked to the AI to get there, especially the parts where it went badly.</p>

<p>If you only want the method, the next section is the part to steal. Everything after it is what happens when you actually use it.</p>

<h2 id="the-loop-one-chat-two-models">The loop: one chat, two models</h2>

<p>Everything ran inside the Claude Code desktop app, in one long chat, switching between two models and two modes. I barely touched regular Claude chat for this project.</p>

<p>The loop: plan with Opus in plan mode, switch to Sonnet with accept edits, let it build, look at the preview, go back to plan mode with Opus, repeat. Plan, code, plan, code, for weeks. Then deploy.</p>

<p>Why one chat instead of fresh sessions: the plan and the build need to share context. Opus writes the plan knowing the whole codebase, and Sonnet implements it with that same history sitting right above it. Switching the model is not starting over. It is handing the same conversation to a different brain.</p>

<p>The mechanics that took me a while to figure out:</p>

<p><strong>Make the plan do the thinking.</strong> I told Opus, explicitly, to make the plan detailed enough that Sonnet does not need to think, just implement. The expensive reasoning happens once, up front, and every decision gets baked into the plan. Sonnet then executes a spec instead of inventing one, which also means it wanders off less.</p>

<p><strong>Comment on the plan instead of accepting it.</strong> When Claude Code presents a plan, you can accept it or make changes first. If I accepted, Opus would start implementing immediately, on Opus, the expensive way. So I read the plan top to bottom and dropped a comment wherever something was off (“no, this is not what I had in mind”), added any general ideas to the prompt, and sent it back for another planning pass. Usually one or two rounds and the plan was right. Only then did I switch the model to Sonnet, flip to accept edits, and tell it to follow the plan. The model swap is the go signal.</p>

<p><strong>When you get disconnected, paste the plan back.</strong> I got disconnected a lot. Just saying “continue” makes things fuzzy. What worked: copy the whole plan back into the chat and say “go on, keep working on this.” Tedious. Also the reason the build never drifted.</p>

<p><strong>Which models, for the record.</strong> Opus 4.8 with thinking on high for planning. Sonnet 4.6, also on high, for building. I did try Opus for implementation early on and dropped it fast: the output was not meaningfully better at executing an already detailed plan, and it ate my usage. Anthropic has a <a href="https://claude.com/resources/tutorials/choosing-the-right-claude-model">guide on picking models</a> that lands in the same place. I am on the Pro plan, for context.</p>

<!-- MEDIA SUGGESTION: a screenshot of Claude Code plan mode with one of your inline comments on a plan line. It makes "comment, don't accept" instantly concrete. -->

<h2 id="attempt-one-total-freedom-total-slop">Attempt one: total freedom, total slop</h2>

<p>What I had before this all started was a perfectly decent portfolio. Dark lavender theme, a 3D particle field in the hero you could push around with your cursor, smooth scroll, animated sections. Professional and polished, and that was the ceiling. Every section was some variation of a card grid. Zero personality.</p>

<p>So I opened a fresh session and gave Claude the dream brief: full visual redesign, start from zero, pick a direction, design every section with a distinct identity.</p>

<p>It picked “soft brutalism.” Clean, structured, legible, and completely soulless. My response, verbatim:</p>

<blockquote>
  <p>“you know what, this lacks so much character. the old portfolio was way way ahead of leagues, with moving 3d cards, blog cards moving, the hero section, now it is more ai slop actually. […] and this color itself screams ai slop. i am written by a shitty ai bot. the old lavender theme the glow everything was so so so so leagues ahead, i thought this would be useful but this is so shitty. can you do anything about this. not one element i like about this.”</p>
</blockquote>

<p>Then the rollback:</p>

<blockquote>
  <p>“i want you to remove all these changes done. fully roll back to the state we were before. drop everything. and just put a md file documenting what you tried and it went wrong what i said i did not like etc.”</p>
</blockquote>

<p>Back to lavender. And the failure was mine, not the model’s. “Design a portfolio” with no constraints produces the statistically most average portfolio, because the average is exactly what the model samples from when you give it nothing else. I had already learned a version of this lesson building <a href="/posts/2026/04/29/chibi-design-system/">Chibi</a>, where the whole idea was that a defined visual language exists so the AI is not guessing. I just had not connected it to this project yet.</p>

<h2 id="attempt-two-references-everywhere-none-used">Attempt two: references everywhere, none used</h2>

<p>New approach: give it taste through references. I had three sites I genuinely love. <a href="https://buttermax.net">buttermax.net</a>, with a magnetic cursor that deforms like fluid. <a href="https://igloo.inc">igloo.inc</a>, with its 3D scroll effects. <a href="https://drumspirit.be">drumspirit.be</a>, with fluid section morphing. Plus screen recordings of specific effects I wanted, plus some Spider-Verse comic energy. I sent all of it.</p>

<p>The result used none of it.</p>

<blockquote>
  <p>“man i want to say, i am so so disappointed right now. i gave so many so many good ideas and references and (attaching the screenshots) this is what you came up with? there was not a single feature i think you used.”</p>
</blockquote>

<p>So I sent the prompt I had been holding back:</p>

<blockquote>
  <p>“I am feeling like you are trying very hard to stick to the current code, the current repo or the current design. if this is difficult, i can say that start from scratch, use these amazing references, […] search the web for award winning design. i believe we can match the level of a fully well designed award winning website. so YOU ARE FREE TO DO WHAT YOU WISH. GIVE ME YOUR BEST.”</p>
</blockquote>

<p>Remember that line, because it failed here and worked later, and the difference is entirely about when you say it.</p>

<p>This era also produced a throwaway practical note that became a permanent rule, after Claude ran the dev server and hung my MacBook so badly the battery was draining while plugged in:</p>

<blockquote>
  <p>“also keep work and do not run the dev server after each change as i just saw, it hanged my macbook pro real bad.”</p>
</blockquote>

<p><code class="language-plaintext highlighter-rouge">npm run dev</code> starts a server that never exits. Claude runs it, waits for it to finish, and it never finishes. Into the CLAUDE.md it went:</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>NEVER run npm run dev in this project, it hangs the machine.
Use npm run build (it exits clean) then the preview tool.
</code></pre></div></div>

<p>Whatever your equivalent long-running command is, ban it on day one.</p>

<h2 id="the-session-where-it-clicked">The session where it clicked</h2>

<p>After a few more sessions of improving-but-not-crystallising, I did the thing that finally worked. I opened a clean session, told Claude to ignore every earlier attempt, and asked it to only think, not build.</p>

<blockquote>
  <p>“so we are now redesigning and not implementing. so think think and think. I have given you all the tools…. i started this new chat to not bring any old trash with this. […] I do not care about the usage, i want the monument of a portfolio filled with character, animation, elements, a blessing to looks and interact with.”</p>
</blockquote>

<p>This is the plan-then-build split earning its keep. A planning-only session, Opus on high, no file edits allowed. Just thinking. And the concept that came back was the whole game.</p>

<p>THE PRESS. A living risograph broadsheet that prints itself as you scroll. Kinetic type that falls and slams into place. A registration crosshair cursor. Redaction bars that reveal like declassifying documents. A whole editorial, letterpress print metaphor.</p>

<p>I read the plan. I said do it. And the same words that produced mush in attempt two now produced the best work of the project, because this time there was a frame to be free inside of.</p>

<h2 id="watching-the-build-dumping-the-feedback">Watching the build, dumping the feedback</h2>

<p>Sonnet kept a visual preview running the whole time it worked, and I kept it open and watched. Not just the end result. I would glance at the page as it changed, skim the copy, and sometimes read the thinking to see what it was trying to do. The reviewer was me looking at the site, not the model grading itself.</p>

<p>When I caught problems, I did not interrupt. Sonnet sometimes ran 30 to 40 minutes on one turn, and stopping it mid-build is worse than waiting. I kept a separate note open and wrote ideas down as they came, because I would absolutely forget them otherwise. Then when the turn ended, I dumped everything in one message:</p>

<blockquote>
  <p>“what established in 2017? i mean i was born in 2002? […] the grab things is a bit phoney. […] The project card expansion is breaking the red line going. fix that. […] the contact or whatever section that was supposed to be after the blog is just a red screen. there is nothing.”</p>
</blockquote>

<p>Six problems in one message, each specific enough to act on. The copy claimed I was established in 2017. I would have been fifteen. The “grab things” was a physics simulation in the Skills section where you could pick up letters and throw them around. Fun for ten seconds, unreadable as a skills section, and it got cut along with a lot of other clever ideas: the fake newspaper masthead, a dispatch ticker, a halftone monogram, a vertical red connector line that jerked every time a card expanded. The site got better every time something was removed.</p>

<p>The other thing that needed correcting: the copy kept latching onto one part of my work and overweighting it, and it had started referring to me in the third person. “Tejal did this.” It is my site. I should be talking. First person everywhere, and that rule stayed.</p>

<p>One more pass came from this prompt:</p>

<blockquote>
  <p>“and this is going a bit too towards newspaper, i do not even have anything much to do with that. so rethink a bit.”</p>
</blockquote>

<p>The press concept was generating great decisions about typography, motion, and palette. But the literal newspaper props were making the theme the subject instead of me. The call we landed on: keep everything that came from a good design principle that happened to use the press metaphor, cut everything that required the visitor to understand the newspaper reference to make sense.</p>

<!-- MEDIA SUGGESTION: a short clip or GIF of the kinetic headline characters dropping into place on the live site. This is the signature effect and no amount of prose replaces seeing it. -->

<h2 id="the-mud-problem">The mud problem</h2>

<p>The last big fight was color. I sent four screenshots of section transitions with this:</p>

<blockquote>
  <p>“all these, and the dotted one especially, it is not looking good and looks unfinished, either change it to let it mix better and i think the main issue is the color, this whole mud color is not seeming good. the red cream etc looks great but this mud feels very weird.”</p>
</blockquote>

<p>I did not know what was technically wrong. I just knew it looked like mud. That was enough. The dark backgrounds were <code class="language-plaintext highlighter-rouge">oklch(20% 0.018 60)</code>: low lightness, near-zero chroma, yellowish hue. Against the warm cream and the press red, that near-neutral read as muddy brown. The fix was to make the dark ground the dark end of the red family instead. The press red sits at hue 27, so the new ground became <code class="language-plaintext highlighter-rouge">oklch(17% 0.060 27)</code>: same hue, modest chroma, very low lightness. A dark red ink. Now the whole page is one hue story, cream to dark red-ink to vivid red, and the dark sections read as the dark end of the same palette instead of a different theme dropped in.</p>

<p>Notice the wording in that prompt, though, because this is how I gave feedback the whole way through. Not “remove this.” Instead: here is roughly what I want in its place, now you figure out how. When I did not like something, I described what I pictured instead of prescribing the fix. That keeps Claude from fixating on my exact suggestion while still giving it a direction to aim at.</p>

<!-- MEDIA SUGGESTION: before/after screenshots of the mud seam vs the dark red-ink ground. The color story is hard to appreciate in words. -->

<h2 id="the-bug-that-only-broke-in-production">The bug that only broke in production</h2>

<p>One morning the Cloudflare Pages deploy started failing with <code class="language-plaintext highlighter-rouge">Could not resolve entry module "three"</code>. The cause: the Vite config was still splitting <code class="language-plaintext highlighter-rouge">three</code> and <code class="language-plaintext highlighter-rouge">framer-motion</code> into separate build chunks, except neither package was installed anymore. The dev server is lazy and never resolved them, so locally everything worked. The production build actually bundles everything, hit the phantom modules, and choked. The fix was deleting two lines.</p>

<p>The lesson that stuck: what runs locally is not what ships. Which leads to the last step.</p>

<h2 id="ship-it-then-let-people-break-it">Ship it, then let people break it</h2>

<p>Get it on a real domain early. The deployed site surfaces things the preview never does: real browser rendering, a real screen, the actual domain. And after staring at your own site for weeks you stop being able to see it, so I asked friends to just use it and tell me where it felt slow, confusing, or off.</p>

<p>Their notes plus mine went back to Sonnet in as much detail as I could manage, screenshots attached. One practical annoyance: Claude Code caps you at five images per message. I spent the slots on things a screenshot explains faster than words, and described everything else in text. Five is not a lot when half your site has something you want to point at.</p>

<h2 id="what-id-tell-you-to-steal">What I’d tell you to steal</h2>

<ol>
  <li><strong>Write your taste constraints first, not last.</strong> My CLAUDE.md says things like “Bold design choices over safe ones. The portfolio is a playground, not a LinkedIn profile. Safe is wrong here.” Those lines went in after the first disaster. They should have gone in before it.</li>
  <li><strong>“Do what you wish” only works inside a frame.</strong> Said with no constraints, it produces the average of the internet. Said after a strong concept is locked, it produces the best work. Same words, different timing.</li>
  <li><strong>Delegate execution, not taste.</strong> Claude is excellent at implementing an animation you describe, finding color values for a relationship you define, researching options for a pattern you want. It cannot decide what your site should feel like. You bring that part every time.</li>
  <li><strong>Describe what you see, suggest what you want, skip the diagnosis.</strong> “This looks like mud” plus “make it mix better” got to the right fix faster than I could have. You do not need the technical root cause to give complete feedback.</li>
  <li><strong>If you keep rolling back, fix the brief, not the implementation.</strong> Both of my full rollbacks were brief problems. You cannot implement your way out of a wrong concept.</li>
  <li><strong>Plan with the expensive model, build with the fast one, same chat.</strong> And do not ask one model for the plan and the build in a single breath. That mistake cost me whole afternoons.</li>
</ol>

<h2 id="questions-i-actually-get-asked">Questions I actually get asked</h2>

<p><strong>Do I need to know how to code?</strong> You do not need to write the code, but you need to be able to judge what comes back and you need enough git to do a rollback without panicking. The job is taste and review. Claude does the typing.</p>

<p><strong>What did this cost?</strong> A Claude Pro subscription, which I already had, and about $7 a year for the domain from Namecheap. Hosting was free. If you are a student, the <a href="https://education.github.com/pack">GitHub Student Pack</a> bundles a lot of free dev tools, and <a href="https://jhaxce.github.io/student-perks/">this list</a> collects most of what is out there.</p>

<p><strong>Where do I host it?</strong> For a static site, GitHub Pages or Cloudflare Pages. Both are free and both redeploy automatically when you push to the repo. This blog runs on GitHub Pages; tgoyal.me runs on Cloudflare Pages. Point your domain at either and you are done.</p>

<p><strong>Is it safe to let an AI run commands on my machine?</strong> Claude Code asks before running things, and you control how much it is allowed to do on its own. The real risks in my experience were boring ones: a long-running command that hangs the session (ban those in your CLAUDE.md), and secrets or personal info ending up in a repo that later goes public. Review what is in the repo before publishing it, and never paste API keys into the chat.</p>

<p><strong>What about the site itself being a security risk?</strong> A static portfolio has no backend, no database, and no login. There is close to nothing to attack. This is one of the few projects where you can vibe code with a clear conscience.</p>

<p><strong>How long did it take?</strong> A few weeks of evenings, and most of that time was me reviewing and giving feedback rather than waiting on the model. A simpler site would take days.</p>

<p><strong>Won’t it look AI generated?</strong> Only if you give it nothing to work with. That is what attempt one was. The slop is not in the tool, it is in the empty brief.</p>

<h2 id="where-it-landed">Where it landed</h2>

<p>As of June 2026, <a href="https://tgoyal.me">tgoyal.me</a> is live and I am happy with it. Cream paper, dark red-ink, vivid press red. Characters that drop into place. 3D cards. A crawl that speeds up when you scroll fast. Torn paper edges between color sections. A registration cursor. An APPROVED stamp in the footer.</p>

<p>For the curious, the stack is React 19, Vite 7, and Tailwind v4 with OKLCH tokens throughout, GSAP and ScrollTrigger for motion, Lenis for scroll, all hanging off one shared ticker. The whole motion system lives in one folder: the kinetic headline, the cursor, the redaction bars, the torn seam, the crawl.</p>

<p>Still on the list: a proper light mode pass, a better mobile experience, and maybe an easter egg or two in Contact. The site does what I wanted. It has a point of view, and it is something you interact with rather than read through. If it makes one person think “I want a site like that,” it did its job.</p>

<hr />

<p><em>Built over a few weeks with Claude, Opus for the hard thinking and Sonnet for the building. Source at <a href="https://github.com/tejalgoyal2">github.com/tejalgoyal2</a>. Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a>.</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><category term="project" /><summary type="html"><![CDATA[The first time I gave Claude total creative freedom over my portfolio, it produced the most average website I have ever seen. The second time, I handed it three reference sites I genuinely love and it ignored all of them. The third attempt became tgoyal.me, and the difference between the three attempts is the entire point of this post.]]></summary></entry><entry><title type="html">How to Build a Resume Skill in Claude That Tailors Itself to Every Job</title><link href="https://tejalgoyal2.github.io/posts/2026/06/05/build-your-own-resume-skill/" rel="alternate" type="text/html" title="How to Build a Resume Skill in Claude That Tailors Itself to Every Job" /><published>2026-06-05T00:00:00+00:00</published><updated>2026-06-05T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/06/05/build-your-own-resume-skill</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/06/05/build-your-own-resume-skill/"><![CDATA[<p>A few people have asked me some version of the same question: how do you make your resumes? The honest answer is that I do not make them one at a time anymore. I built a skill that does it, and I point it at a job description.</p>

<p>The follow-up is usually whether I can just share that skill. I cannot, and the reason is worth explaining, because it is also the reason this post exists. My skill is full of my resume. Every real bullet I have, my contact details, the specifics of what I have actually done. Handing it over would mean handing over all of that, and you would still be left with a resume that describes me instead of you.</p>

<p>So here is the method instead. Build your own, with your own content. It is not complicated, and the structure is the part that matters.</p>

<h2 id="what-a-skill-actually-is">What a skill actually is</h2>

<p>A skill in Claude is a folder. Claude reads the instructions inside it and can run the code inside it. Mine has three parts and nothing more:</p>

<div class="language-text highlighter-rouge"><div class="highlight"><pre class="highlight"><code>my-resume-skill/
  SKILL.md          # the instructions Claude follows
  references/
    master.md       # every real bullet you have
  scripts/
    build.js        # generates the document and fits it to the page
</code></pre></div></div>

<p>The current steps for adding a skill to Claude live in <a href="https://docs.claude.com">Anthropic’s documentation</a>, and that is the source of truth, so I am going to keep this post about the parts that are actually mine to explain: what goes in each file, and why.</p>

<h2 id="step-1-write-your-master-resume-first">Step 1: Write your master resume first</h2>

<p>Before any automation, write one document that contains everything true about you. Every role, every project, every bullet you could plausibly want to use, written out properly. This is your source of truth, and the most important file in the whole system.</p>

<p>The skill never invents anything. It only selects from this.</p>

<p>If you apply to more than one kind of role, keep more than one master. I keep separate ones for the different directions I apply in, because a bullet that is perfect for one kind of job is just noise on another. Either way, the raw material is real and already written. Tailoring becomes a selection problem, not a writing-from-scratch problem.</p>

<blockquote>
  <p>The single most important rule of the whole system: the model selects and trims. It does not write new accomplishments. If it is not in your master, it does not go on the resume.</p>
</blockquote>

<h2 id="step-2-write-the-instructions">Step 2: Write the instructions</h2>

<p>The SKILL.md file is where you tell Claude how to behave. Mine covers a handful of things, all in plain language:</p>

<ul>
  <li><strong>Select from the master, do not rewrite.</strong> Pick the bullets that match the job. Leave the rest.</li>
  <li><strong>Keep a length budget.</strong> One page. A fixed number of bullets, with a few extras held in reserve for when there is room.</li>
  <li><strong>Mirror the posting’s language.</strong> If the job says “incident response” and you have done incident response, use their words, because plenty of resumes are read by software before a person ever sees them. But do not stuff keywords. A human reads it next, and keyword soup is obvious and embarrassing.</li>
  <li><strong>Do not inflate.</strong> This one matters far more than it sounds. Tell the model explicitly that confidence is not inflation: contributed is not authored, helped build is not built, supported is not led. I learned why that rule has to be written down the hard way, which is a story I told <a href="/posts/2026/06/03/resume-builder-slight-overflow/">in the other post</a>.</li>
</ul>

<h2 id="step-3-make-it-fit-the-page-by-itself">Step 3: Make it fit the page by itself</h2>

<p>This is the part most people skip, and it is the part that separates a resume system from a resume-shaped text generator.</p>

<p>A one-page resume has to actually be one page. Full, but not spilling onto a second. The obvious approach is to guess length from how many characters you have. Do not do this. Character count is a bad proxy, because whether a bullet takes two lines or three depends on the exact font, the margins, and where the words happen to wrap.</p>

<p>Instead, render the resume to a real document and measure it. My build script generates the document, converts it to a PDF with a headless office renderer, and measures how much of the page the content fills. That gives a real number: a little under one page, exactly one page, or spilled over.</p>

<p>Once you can measure, you can correct automatically. If it is under-full, pad by pulling a held-back bullet from your reserve list. If it is over-full, trim by cutting the weakest bullet, starting with the oldest role and never touching your current one. Loop until it lands on one full page. The point is that this happens inside a single run, without you refereeing every pass.</p>

<!-- MEDIA SUGGESTION: a simple flow diagram - select bullets from master, build the document, measure page fill, then pad if under or trim if over, looping back until it is exactly one page. It makes the auto-fit loop concrete. -->

<p>To do this you need a small build environment: a way to run the script, and a headless renderer to turn the document into something measurable. I use Node for the first and LibreOffice for the second, but the principle does not depend on the tools. Measure with whatever you have. Look at the real page, not a guess.</p>

<h2 id="step-4-the-rules-that-actually-matter">Step 4: The rules that actually matter</h2>

<p>Most of what makes the output good is a short list of rules I arrived at by getting them wrong first:</p>

<ul>
  <li><strong>Bullets are one to two lines. Never three.</strong> Find the character count where your layout wraps onto a third line and treat it as a hard ceiling. For my font and margins it sits around 250 characters. Yours will be different, so measure it once and write it down.</li>
  <li><strong>One page, full or slightly over, then trim by hand if you have to.</strong> Empty space at the bottom looks unfinished. A second page with three lonely lines on it looks worse.</li>
  <li><strong>Select, do not rewrite.</strong> I have said this. I am saying it again because it is the rule people break first.</li>
  <li><strong>Mirror the posting, do not stuff it.</strong></li>
  <li><strong>Never upgrade your own credit.</strong></li>
</ul>

<h2 id="step-5-use-it">Step 5: Use it</h2>

<p>Once the folder is built and added to Claude, the day-to-day is genuinely simple. Paste in a job description. The skill reads it, selects the bullets from your master that fit, mirrors the relevant language, builds the document, and fits it to the page. You read the result, fix anything that feels off, and send it.</p>

<p>The first build of the skill takes real effort. Every build after that takes about a minute. That trade is the entire reason the thing exists.</p>

<h2 id="on-sharing-and-why-yours-has-to-be-yours">On sharing, and why yours has to be yours</h2>

<p>Back to where this started. I cannot give you mine, because mine is my resume, and you would not actually want it, because a tailored resume is only useful when it is built from true things about the person sending it. The value was never in my files.</p>

<p>It is in the structure: a real master document, a clear set of instructions, and a build that measures the page instead of guessing at it. Build that with your own history and you will have something better than anything I could hand you. A resume system that tells the truth about you, on one page, in under a minute.</p>

<p>If you want the messy version of how I got here, with the page-and-a-half disasters and the evening I lost to a single comma, that is <a href="/posts/2026/06/03/resume-builder-slight-overflow/">over here</a>. The original build is documented in <a href="/posts/2026/04/03/ai-resume-system/">this post</a> and <a href="/posts/2026/04/05/build-your-own-ai-resume-pipeline/">this companion one</a> if you want the back catalogue.</p>

<p><em>Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a>.</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><summary type="html"><![CDATA[A few people have asked me some version of the same question: how do you make your resumes? The honest answer is that I do not make them one at a time anymore. I built a skill that does it, and I point it at a job description.]]></summary></entry><entry><title type="html">My Resume Builder Thought 120% of a Page Was ‘Slightly Over’</title><link href="https://tejalgoyal2.github.io/posts/2026/06/03/resume-builder-slight-overflow/" rel="alternate" type="text/html" title="My Resume Builder Thought 120% of a Page Was ‘Slightly Over’" /><published>2026-06-03T00:00:00+00:00</published><updated>2026-06-03T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/06/03/resume-builder-slight-overflow</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/06/03/resume-builder-slight-overflow/"><![CDATA[<p>Back in April I wrote that my resume system <a href="/posts/2026/04/03/ai-resume-system/">finally worked</a>, and then almost immediately wrote a <a href="/posts/2026/04/11/optimizing-ai-resume-system/">second post about breaking it</a> while trying to make it better. I would like to report personal growth since then. I cannot.</p>

<p>Because a few weeks later I opened it back up, and the very first resume it produced was a page and a half long. The build script looked at that page and a half, checked its little internal threshold, and decided this was “slight overflow.”</p>

<p>A page and a half. <em>Slightly</em> over. Sure.</p>

<!-- MEDIA SUGGESTION: a screenshot of a resume spilling three or four lines onto a second page, captioned "slight overflow." The gap between what the script claimed and what the page actually looked like is the whole joke. -->

<h2 id="the-lie-was-in-the-measurement">The lie was in the measurement</h2>

<p>Here is the thing the old version never did: look at the page.</p>

<p>It estimated length from character counts. Add up the letters, compare to a number it had in its head, declare victory. The problem is that character count is a terrible way to predict how long a document is. A bullet at 240 characters and a bullet at 260 characters can be the difference between two lines and three, depending entirely on where the words happen to wrap. The script had no idea. It just counted letters and felt confident.</p>

<p>So “slight overflow” was never a measurement. It was a guess wearing the costume of a measurement.</p>

<p>The April version worked the way a stopped clock works. Right often enough that I stopped checking.</p>

<h2 id="so-i-made-it-actually-look-at-the-page">So I made it actually look at the page</h2>

<p>The fix was conceptually simple and annoyingly overdue. Build the resume into a real document, convert it to a PDF, and <em>measure how much of the page the content fills.</em></p>

<p>Now the number means something. <code class="language-plaintext highlighter-rouge">0.97</code> means it is sitting at ninety-seven percent of one page, a little empty at the bottom. <code class="language-plaintext highlighter-rouge">1.06</code> means it spilled onto a second page by six percent. These come from the actual rendered document, not from vibes.</p>

<p>And once it can measure, it can fix itself in a single run. Under-full? It pads, pulling a bullet I had held back in a reserve list. Over-full? It trims, cutting the weakest bullet, starting with the oldest role and never touching my current one. It loops until it lands on one full page. No asking me. No second prompt. It just converges and hands me the result.</p>

<p>It went from confidently wrong to quietly correct. I will take it.</p>

<h2 id="the-part-where-i-lost-sleep-over-single-words">The part where I lost sleep over single words</h2>

<p>At this font and these margins, a bullet wraps onto a third line somewhere around 250 characters. Two lines is good. Three lines is a waste of space I do not have. So every bullet has to land under that ceiling, which meant I spent an embarrassing number of evenings deleting single words to claw back a line.</p>

<p>“Implemented” becomes “Built.” “In order to” becomes “to.” Whole sentences rearranged to save eight characters.</p>

<p>There is no version of me from five years ago who would believe that I once stayed up arguing with myself about whether one comma was worth a second line, on a document most people skim for nine seconds.</p>

<blockquote>
  <p>Monaco is <a href="https://www.formula1.com/en/racing/2026">this weekend</a>, which means I should be doing literally anything to emotionally prepare for it. As I write this, <a href="https://www.formula1.com/en/results/2026/drivers">a Mercedes is running away with the championship</a>, and Ferrari is doing its traditional thing where it is fast enough to make me hope and never quite fast enough to win. Anyway. Resume margins. Where was I.</p>
</blockquote>

<h2 id="it-was-also-lying-about-me">It was also lying about me</h2>

<p>While reading the output, I noticed the resume was weirdly <em>modest.</em> It kept saying things were “underway,” that reviews were “in progress,” that I was “actively” doing this and that.</p>

<p>Hedge words. On a resume. Where the entire job of a line is to say what you did, cleanly and without a disclaimer.</p>

<p>So I killed the hedges. “Underway” is not an accomplishment. Either I did the thing, in which case say it, or I did not, in which case it does not belong on the page.</p>

<h2 id="and-then-it-got-too-confident">And then it got too confident</h2>

<p>The opposite problem showed up too, and this one I am less proud of.</p>

<p>At some point the model, trying to make me sound impressive, turned “contributed to a published paper” into “co-authored a published paper.” I contributed to one. I am not a named author on it. Those are different sentences, and the difference between them is the entire point.</p>

<p>So I wrote a rule into the system, in plain words: confidence is not inflation. Do not turn <em>helped build</em> into <em>built.</em> Do not turn <em>contributed</em> into <em>authored.</em> A resume can be sharp without claiming things that are not mine.</p>

<p>A resume that oversells is a problem you only discover later, in the interview, and by then it is sitting in the room wearing your face.</p>

<p>I would rather be accurately good than impressively fake.</p>

<h2 id="the-cover-letter-got-the-same-surgery">The cover letter got the same surgery</h2>

<p>While I was in there, the cover letter side needed help too. It read like three paragraphs that had never met each other. Here is why your company. Here is my experience. Here is a polite goodbye. Three blocks, stacked.</p>

<p>So I rewrote how it builds them, so the whole thing reads like one person actually talking, each paragraph leading into the next, and so the opening sounds like I specifically want to work <em>there</em> and not like a template with the company name pasted in.</p>

<p>The test for whether a sentence belongs in a cover letter is simple. If you could lift it straight onto the resume, it is the wrong sentence.</p>

<h2 id="where-it-landed">Where it landed</h2>

<p>It fits one page. It measures that page itself, every single time, and pads or trims until it is full without spilling. It does not hedge and it does not oversell.</p>

<p>It cost, conservatively, three weeks of evenings and one genuine crisis about a comma. Worth it? I apply to a <em>lot</em> of jobs. Yes.</p>

<p>If you want the actual how-to, the one where I explain how to build a system like this for yourself instead of just complaining about mine, I wrote that <a href="/posts/2026/06/05/build-your-own-resume-skill/">over here</a>. The messy story lives in this post. The useful part lives in that one.</p>

<p><em>Built with Claude, far too much LibreOffice, and the quiet dread of a Monaco weekend. Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a>.</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><summary type="html"><![CDATA[Back in April I wrote that my resume system finally worked, and then almost immediately wrote a second post about breaking it while trying to make it better. I would like to report personal growth since then. I cannot.]]></summary></entry><entry><title type="html">WalletRIP Had a Security Problem. I Didn’t Fix It. Here’s the Full Story.</title><link href="https://tejalgoyal2.github.io/posts/2026/05/20/walletrip-to-dime/" rel="alternate" type="text/html" title="WalletRIP Had a Security Problem. I Didn’t Fix It. Here’s the Full Story." /><published>2026-05-20T00:00:00+00:00</published><updated>2026-05-20T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/05/20/walletrip-to-dime</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/05/20/walletrip-to-dime/"><![CDATA[<p>In early 2025, a vulnerability in Next.js middleware was publicly disclosed that allowed attackers to bypass authentication entirely — regardless of what your auth logic said. You’d check for a valid session, it would pass, and a crafted request could skip the whole check. <a href="https://www.picussecurity.com/resource/blog/cve-2025-29927-nextjs-middleware-bypass-vulnerability">CVE-2025-29927</a>. It was bad, it got patched, and it was the kind of thing that makes you look at your own projects and think <em>“okay, what else is wrong here.”</em></p>

<p>WalletRIP was on Vercel. WalletRIP used Next.js middleware for auth. WalletRIP had… other problems too, independent of the CVE. I didn’t fix any of it. I want to be honest about why, because “I was busy” is true but it’s not the whole picture.</p>

<h2 id="what-walletrip-actually-was">What WalletRIP actually was</h2>

<p><a href="https://github.com/tejalgoyal2/WalletRIP">WalletRIP</a> was my first real full-stack project. I built it in December 2025 in roughly two weeks, deployed it to Vercel, and used it daily. It worked. Natural language expense logging, Gemini parsing, Hinglish roasts, subscription detection — all the features I wanted. The code was messier than I’d write today, but it ran.</p>

<p>The security posture was… let’s call it optimistic.</p>

<p>The biggest issue: the client was writing directly to Supabase. When you logged an expense, your browser made a Supabase insert call with the anon key. Row-level security meant you could only write to your own data — so it wasn’t catastrophic — but there was no server-side validation. Whatever Gemini returned, the client trusted and inserted. Malformed amounts, unexpected categories, whatever. It went straight into the database.</p>

<p>The rate limiter was in-memory. I had a <code class="language-plaintext highlighter-rouge">Map</code> in module scope that tracked requests per IP. On a real serverless platform, every cold start creates a fresh process. Every fresh process has an empty Map. The rate limiter reset approximately constantly. It was not a rate limiter. It was a rate limiter-shaped comment in the code.</p>

<p>The <code class="language-plaintext highlighter-rouge">withRetry</code> function had an off-by-one error that made it run four attempts instead of three. Minor, but it’s the kind of thing that tells you the code wasn’t reviewed carefully.</p>

<p><code class="language-plaintext highlighter-rouge">select('*')</code> everywhere. No column projection. Every fetch returned every field including any future ones — a pattern that leaks data you didn’t mean to expose.</p>

<p>There was also an invite code validation endpoint with no rate limiting of its own. Five guesses a minute indefinitely. The invite code was short.</p>

<p>None of this was catastrophic for a personal app where I’m the only real user. But “probably fine for just me” is not a real security posture.</p>

<h2 id="why-i-didnt-fix-it">Why I didn’t fix it</h2>

<p>Here’s the honest answer: it was winter, I had a co-op lined up, I was watching Formula 1 and <em>The Boys</em>, and fixing security debt in a working personal project that only I use felt like exactly the kind of thing I could do later.</p>

<p>This is not the heroic “I identified the problems and immediately rewrote everything” story. I identified the problems and wrote them down in an audit report that I did not act on for several months.</p>

<p>The Vercel CVE was the thing that moved it from “later” to “now.” Not because WalletRIP was actively exploited — it wasn’t, as far as I know — but because looking at the CVE made me look at the rest of the code, and looking at the rest of the code made me realize I didn’t want to spend time patching a codebase I wasn’t proud of. The architecture was the problem. A patch wouldn’t fix architecture.</p>

<p>So I rewrote it.</p>

<!-- MEDIA SUGGESTION: The "this is fine" dog meme. Literally the correct image for this section. -->

<h2 id="dime-vs-walletrip-the-actual-differences">Dime vs WalletRIP: the actual differences</h2>

<p><a href="https://dime.tgoyal.me">Dime</a> is the rewrite. Same concept, different everything under the hood.</p>

<p><strong>Writes go through the server.</strong> The client never touches Supabase directly. Every mutation hits an API route that checks auth, validates with Zod, and then writes. This means actual server-side validation on every request — not “trust whatever Gemini returned.”</p>

<p><strong>Rate limiting that works.</strong> Upstash Redis, sliding window, persistent across Workers isolates. 20 requests per minute on AI routes, 5 per 15 minutes on invite validation. Numbers I actually thought about.</p>

<p><strong>TypeScript strict, Zod v4 everywhere.</strong> No <code class="language-plaintext highlighter-rouge">any</code>. Shared schemas between client and server so the shape of data is checked at the boundary, not just assumed.</p>

<p><strong>Origin checking.</strong> API routes validate the <code class="language-plaintext highlighter-rouge">Origin</code> header. Not bulletproof on its own but part of a defense-in-depth approach.</p>

<p><strong>Column projection.</strong> <code class="language-plaintext highlighter-rouge">select('id, item_name, amount, category, type, date, emoji')</code> — not <code class="language-plaintext highlighter-rouge">select('*')</code>. Explicit about what comes back.</p>

<p><strong>Cloudflare Workers instead of Vercel.</strong> This wasn’t primarily a security decision — I wanted the edge performance and I wanted to learn the Workers deployment model. But it does mean the middleware CVE class of vulnerability is someone else’s problem now.</p>

<p>The full technical walkthrough is in <a href="https://github.com/tejalgoyal2/Dime/blob/main/WALKTHROUGH.md">WALKTHROUGH.md</a> in the Dime repo. Every error I hit during the rewrite, documented in order, including the <code class="language-plaintext highlighter-rouge">runtime = "edge"</code> trap on Cloudflare Workers that caused silent 500 errors with no stack trace for two hours.</p>

<h2 id="the-vercel-middleware-thing-specifically">The Vercel middleware thing specifically</h2>

<p>CVE-2025-29927 worked by manipulating the <code class="language-plaintext highlighter-rouge">x-middleware-subrequest</code> header. Next.js middleware uses this header internally to track subrequest depth and avoid infinite loops. An attacker could send a crafted request with this header set in a way that caused the middleware to skip its own execution — including auth checks.</p>

<p>The patch was straightforward (Vercel deployed it quickly), but the disclosure pattern was uncomfortable: the vulnerability was in the framework itself, not in application code. You could write correct authentication logic and still be vulnerable because the layer that ran your auth logic could be bypassed before your code even ran.</p>

<p>WalletRIP’s auth wasn’t particularly sophisticated — Supabase cookie sessions, checked in middleware, redirect to login if no session. Exactly the pattern the CVE targeted. Would it have been exploited? Probably not. It’s a personal expense tracker with no interesting data. But “probably not” isn’t the same as “couldn’t have been.”</p>

<p>The more useful frame: the CVE is a good reason to audit, not a reason to panic. If your middleware does auth and you were on an unpatched version, patch it and then look at everything else. That “look at everything else” step is where I found the actual problems in WalletRIP.</p>

<h2 id="what-id-tell-someone-in-the-same-situation">What I’d tell someone in the same situation</h2>

<p>You’re going to build a v1 that has security problems. This is fine. The alternative is never shipping anything.</p>

<p>What you should do: write down the problems. Keep an audit document. Don’t let “I’ll fix it later” mean “I’ll never think about it again.” WalletRIP had an <code class="language-plaintext highlighter-rouge">AUDIT_REPORT.md</code> in the repo that documented exactly what was wrong. I wrote it. I just didn’t act on it for a while. At least having it written meant I knew what I was looking at when I finally did.</p>

<p>Also: in-memory rate limiting on serverless is not rate limiting. I feel strongly about this.</p>

<p>The other thing: rewrites are sometimes the right call. Not always — “let’s rewrite it” is a classic way to spend six months rediscovering why the original decisions were made. But when the architecture is the problem and you’re not proud of the codebase, a clean start with clear constraints produces something better. Dime is better than WalletRIP. Not because I’m better at writing code now (though maybe), but because I started with a clearer picture of what I was building and why.</p>

<p>WalletRIP is still live. It’ll stay live. It’s a useful artifact of what v1 looks like — and occasionally I use it to remember that “it works” and “it’s good” are not the same thing.</p>

<hr />

<p><em>The Dime intro post, if you haven’t read it, is <a href="/posts/2026/05/17/dime/">here</a>. The full build walkthrough — every error, every fix, in order — is in the <a href="https://github.com/tejalgoyal2/Dime">repo</a>. · May 2026</em></p>

<p><em><a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a></em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="security" /><category term="project" /><summary type="html"><![CDATA[In early 2025, a vulnerability in Next.js middleware was publicly disclosed that allowed attackers to bypass authentication entirely — regardless of what your auth logic said. You’d check for a valid session, it would pass, and a crafted request could skip the whole check. CVE-2025-29927. It was bad, it got patched, and it was the kind of thing that makes you look at your own projects and think “okay, what else is wrong here.”]]></summary></entry><entry><title type="html">Dime: An Expense Tracker That Actually Has Opinions About Your Spending</title><link href="https://tejalgoyal2.github.io/posts/2026/05/17/dime/" rel="alternate" type="text/html" title="Dime: An Expense Tracker That Actually Has Opinions About Your Spending" /><published>2026-05-17T00:00:00+00:00</published><updated>2026-05-17T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/05/17/dime</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/05/17/dime/"><![CDATA[<p>I’ve been quietly working on something for the past few weeks and it’s finally at a point where I’m not embarrassed to talk about it. It’s called <a href="https://dime.tgoyal.me">Dime</a>, it tracks your expenses, and it will roast you in Hinglish when you buy overpriced coffee for the fourth time in a week.</p>

<p>That last part is non-negotiable.</p>

<h2 id="what-it-is">What it is</h2>

<p>Dime is an AI expense tracker. You type naturally — <code class="language-plaintext highlighter-rouge">"grabbed lunch $14"</code>, <code class="language-plaintext highlighter-rouge">"uber to work $12"</code>, <code class="language-plaintext highlighter-rouge">"therapy after checking my bank statement $200"</code> — and Gemini figures out the rest. Category, emoji, whether it was a need or a want (it’s usually a want). No dropdowns. No category pickers. No suffering.</p>

<p>It’s a full rewrite of <a href="https://github.com/tejalgoyal2/WalletRIP">WalletRIP</a>, which I built last year and which… worked, but had problems. We’ll get into that in a separate post. For now: Dime is the version I actually wanted to build the first time.</p>

<p><strong>Live at <a href="https://dime.tgoyal.me">dime.tgoyal.me</a>.</strong> Invite-only for now — which is a polite way of saying it’s mine and I like it that way.</p>

<h2 id="the-features">The features</h2>

<p><strong>Natural language input</strong> is the whole point. Open the app, type what you spent, close the app. That’s it. The AI handles categorization, amount extraction, and the smug little Hinglish comment that appears after every entry. (“<em>Bhai, ek aur coffee? Budget toh dekh.</em>”)</p>

<p><strong>AI insights</strong> — on-demand Gemini analysis of your last 30 days. What you spent, where it went, what the pattern looks like. It’s useful in the way that doctor’s advice is useful: accurate, slightly uncomfortable, and easy to ignore.</p>

<p><strong>Monthly roast</strong> — hit the button and get a sarcastic performance review of your spending. In Hinglish. This was the first feature I built and the one I use most.</p>

<p><strong>Subscription hunter</strong> — pastes through your expense history and finds the recurring charges you forgot you were paying for. I found two.</p>

<p><strong>Quick Add API</strong> — this is my favorite part. I said “Hey Siri, log expense” and built a Shortcut that asks what I spent, sends it to the API, and logs it without me ever opening the app. Bearer token auth, no session cookies required.</p>

<div class="language-bash highlighter-rouge"><div class="highlight"><pre class="highlight"><code>curl <span class="nt">-X</span> POST https://dime.tgoyal.me/api/quick-add <span class="se">\</span>
  <span class="nt">-H</span> <span class="s2">"Authorization: Bearer YOUR_TOKEN"</span> <span class="se">\</span>
  <span class="nt">-H</span> <span class="s2">"Content-Type: application/json"</span> <span class="se">\</span>
  <span class="nt">-d</span> <span class="s1">'{"text": "coffee at starbucks $5.50"}'</span>
</code></pre></div></div>

<p><strong>Bulk import</strong> — paste a bank statement, Gemini parses the whole thing at once. Preview what it found, deselect anything that’s wrong, confirm. Useful when you’ve been ignoring your finances for three weeks and need to catch up.</p>

<p><strong>Spending charts</strong> — Needs vs Wants donut + weekly/monthly stacked bar trends. The bar chart is the one that actually changes behavior. Seeing that “Wants” stacked up taller than “Needs” for three consecutive weeks in a row is a specific kind of motivating.</p>

<p><strong>CSV export</strong>, streak tracking, dark/light theme. The full stack: Next.js 16 on Cloudflare Workers (via <a href="https://opennext.js.org/cloudflare">@opennextjs/cloudflare</a>), Supabase for auth and data, Gemini 2.5 Flash-Lite for the AI bits, Upstash Redis for rate limiting that actually works across serverless instances.</p>

<h2 id="the-design">The design</h2>

<p><a href="https://github.com/tejalgoyal2/Dime/blob/main/app/globals.css">Neon Midnight</a>. <code class="language-plaintext highlighter-rouge">#0d0d0d</code> background, <code class="language-plaintext highlighter-rouge">#00ff88</code> accent, Syne for headings, JetBrains Mono for the body. The vibe is “developer tool at 2am” which is fitting because that’s when I use it most.</p>

<p>It has a dark/light toggle. The light mode is clean but the dark mode is the one I designed for. I wrote about building a proper design system for this kind of thing in the <a href="/posts/2026/04/29/chibi-design-system/">Chibi post</a> — Dime predates that system, but it shares the same philosophy: one accent color, used sparingly, on the one thing that matters most.</p>

<!-- MEDIA SUGGESTION: A screenshot of the dashboard — expense form + table on mobile, showing the dark theme. Would land well right here as a visual anchor. -->

<h2 id="whats-missing-and-whats-coming">What’s missing (and what’s coming)</h2>

<p>There’s a PATCH endpoint for editing expenses that has no UI. Every time I log something wrong I have to delete it and re-add it. This bothers me more than I expected.</p>

<p>Budget goals are the obvious next thing. Set a monthly limit per category, get a warning when you’re close, ignore the warning, feel bad, repeat. The database is set up for it. The UI isn’t.</p>

<p>Multi-currency is on the list. Right now everything converts to CAD which works for me but would confuse literally everyone else.</p>

<p>There’s a field in the schema called <code class="language-plaintext highlighter-rouge">is_recurring</code> that doesn’t do anything yet. The subscription hunter identifies recurring charges but doesn’t actually flag them in the database. That’s a gap.</p>

<p>Shared expenses — split tracking, IOUs, the “you still owe me $14 from that lunch” conversation — is the kind of feature that sounds simple and is not simple. Probably v2 territory.</p>

<h2 id="the-thing-about-walletrip">The thing about WalletRIP</h2>

<p>I’ll write a proper post about this separately, but the short version: WalletRIP was fine as a first pass and not fine as something I wanted running in production. Client-side database writes, in-memory rate limiting that reset on every cold start, some security choices that made me wince when I looked at them later. Dime fixes all of that. Every mutation goes through server API routes. Rate limiting is persistent across Workers isolates. Input validation runs server-side on every request.</p>

<p>The old version is still live at <a href="https://wallet.tgoyal.me">wallet.tgoyal.me</a>, untouched, as a monument to what v1 looks like. It’s fine. It works. It’s just not what I’d build today.</p>

<hr />

<p><em>Next post: why I built Dime instead of fixing WalletRIP, what the Vercel middleware vulnerability from early 2025 had to do with it, and how much of WalletRIP’s security posture was “it probably won’t matter.” (Spoiler: it probably would have mattered.) · May 2026</em></p>

<p><em><a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a></em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><category term="project" /><summary type="html"><![CDATA[I’ve been quietly working on something for the past few weeks and it’s finally at a point where I’m not embarrassed to talk about it. It’s called Dime, it tracks your expenses, and it will roast you in Hinglish when you buy overpriced coffee for the fourth time in a week.]]></summary></entry><entry><title type="html">Nib: A Menu Bar Scratchpad, an Apple Rant, and the State of AI and Swift</title><link href="https://tejalgoyal2.github.io/posts/2026/05/01/building-nib/" rel="alternate" type="text/html" title="Nib: A Menu Bar Scratchpad, an Apple Rant, and the State of AI and Swift" /><published>2026-05-01T00:00:00+00:00</published><updated>2026-05-01T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/05/01/building-nib</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/05/01/building-nib/"><![CDATA[<p>I had an itch to build something. Not for any grand reason — just that feeling where you want to make a thing and see if you can. The thing I landed on was a menu bar scratchpad for macOS. Simple premise: click an icon in your menu bar, a little window appears, you type, you close it. Your text is still there next time. That’s it. I called it <a href="https://github.com/tejalgoyal2/Nib">Nib</a>.</p>

<p>It shipped. It works. The road to get there taught me something genuinely interesting about AI and Swift that I keep thinking about.</p>

<!-- MEDIA SUGGESTION: "this is fine" dog-in-burning-room — right after the intro, sets the tone before the Swift section -->

<h2 id="ai-is-actually-bad-at-swift-and-i-think-i-know-why">AI is actually bad at Swift, and I think I know why</h2>

<p>I use Claude for basically everything code-related. Python? Excellent. JavaScript? Great. Obscure bash one-liners? Surprisingly confident. I assumed Swift would be in that same bucket.</p>

<p>It is not in that bucket.</p>

<p>The code it generated was <em>technically plausible</em>. It compiled. It looked like real Swift. And then at runtime it would just… not do the thing. No crash. No error. Sometimes a silent success that meant absolutely nothing happened. I’ve seen this before — if you read my <a href="/posts/2026/04/07/building-ontop/">OnTop post</a>, you know exactly the kind of thing I mean.</p>

<p>My theory: there just isn’t that much Swift code in AI training data. Not compared to Python or JavaScript anyway. The open-source macOS app ecosystem is smaller than people think. Apple’s own documentation is gorgeous and about 40% useful. The result is an AI that has <em>seen</em> enough Swift to write something that looks right, but not enough to know what actually works at runtime on a real Mac.</p>

<p>It’s a real problem. I don’t have a solution yet, but I’m thinking about it.</p>

<h2 id="a-brief-necessary-apple-rant">A brief, necessary Apple rant</h2>

<p>The autocorrect on macOS is still broken. I’m writing this and it just changed “SwiftUI” to “Swift Ui” for the fifth time.</p>

<p>I hope by the time you’re reading this they’ve fixed it. I’m choosing to believe they will. That’s what hope is, I think.</p>

<p>Apple makes beautiful hardware, ships genuinely good design direction — Liquid Glass in Tahoe looks incredible — and then wraps it in an OS that occasionally just disagrees with you for no discernible reason. I spent two hours on a Stack Overflow post from 2019 trying to figure out if it still applied to a global keyboard shortcut issue. It did not. I could keep going. I won’t. But I could.</p>

<h2 id="what-nib-actually-does">What Nib actually does</h2>

<p>Menu bar only — no Dock icon. Click the pen nib icon, a popover appears. Type. Close it. Come back. Your text is still there.</p>

<p>Beyond the basics: inline Markdown renders live (not in a preview pane — right there as you type), checkboxes you can click to toggle, word and character count in the toolbar, a pin button that floats Nib above full-screen apps and follows you across Desktop Spaces, one-click copy-all, and a formatting toolbar for when you’d rather click than type syntax. The background uses <code class="language-plaintext highlighter-rouge">ultraThinMaterial</code> so it picks up your wallpaper and system theme automatically.</p>

<p>No cloud. No accounts. No analytics. Your text is a file sitting quietly in Application Support.</p>

<h2 id="the-notion-export-that-didnt-make-v10">The Notion export that didn’t make v1.0</h2>

<p>I wanted Notion export — write something in Nib, hit a button, it lands in a database. The AI-generated integration was rough enough that I cut it and shipped without it.</p>

<p><em>v1.0 without Notion export beats v0 with a broken one.</em> It’s on the list for the next version, along with a global hotkey and settings panel.</p>

<h2 id="the-product-page">The product page</h2>

<p>I built a site for Nib at <a href="https://nib.tgoyal.me">nib.tgoyal.me</a> using <a href="https://github.com/tejalgoyal2/chibi-design-system">Chibi</a> — the design system I wrote about <a href="/posts/2026/04/29/chibi-design-system/">last week</a>. Single HTML file, dark-warm, Cormorant Garamond, interactive app mockup built in HTML because screenshots get outdated. Happy with how it came out.</p>

<h2 id="getting-it">Getting it</h2>

<p><a href="https://github.com/tejalgoyal2/Nib/releases/tag/v1.0.0">DMG is in the releases.</a> macOS will give you the “unverified developer” warning. Right-click → Open → Open. One time, never again.</p>

<p>I’m not paying Apple ninety-nine dollars a year to skip a dialog box. That is my line.</p>

<hr />

<p><em>Built with Claude (doing its best with Swift), Xcode (doing whatever it wanted), and caffeine. Repo at <a href="https://github.com/tejalgoyal2/Nib">github.com/tejalgoyal2/Nib</a>.</em></p>

<p><em><a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a></em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="macos" /><category term="vibe-coding" /><category term="project" /><summary type="html"><![CDATA[I had an itch to build something. Not for any grand reason — just that feeling where you want to make a thing and see if you can. The thing I landed on was a menu bar scratchpad for macOS. Simple premise: click an icon in your menu bar, a little window appears, you type, you close it. Your text is still there next time. That’s it. I called it Nib.]]></summary></entry><entry><title type="html">I Built My Own Sudoku App Because an Ad Interrupted My Winning Streak</title><link href="https://tejalgoyal2.github.io/posts/2026/04/30/ad-free-sudoku/" rel="alternate" type="text/html" title="I Built My Own Sudoku App Because an Ad Interrupted My Winning Streak" /><published>2026-04-30T00:00:00+00:00</published><updated>2026-04-30T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/04/30/ad-free-sudoku</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/04/30/ad-free-sudoku/"><![CDATA[<p>I play Sudoku on my commute. Every day. It’s the one thing that keeps me from doom-scrolling through LinkedIn job posts or reading about whatever Ferrari did wrong this weekend. The app I was using worked fine — until it didn’t.</p>

<p>At some point, the ads went from “mildly annoying banner at the bottom” to “full-screen video ad between every single game.” Mid-streak. Mid-flow. Right when you finish a puzzle and want to ride that momentum into the next one — <em>bam</em>, thirty seconds of some mobile game you’ll never download. The kind of ad placement that makes you wonder if someone on the product team actively hates their users.</p>

<h2 id="the-math-was-simple">The math was simple</h2>

<p>The app wanted a subscription to remove ads. For Sudoku. A game that’s been free in newspapers since before I was born. I’m a student. I’m not paying a monthly fee to fill numbers into a 9x9 grid.</p>

<p>So the options were: find another app (they all have ads), pay up (no), or build my own.</p>

<p><em>…obviously I built my own.</em></p>

<h2 id="the-perplexity-research-phase">The Perplexity research phase</h2>

<p>Before writing a single line of code, I went to Perplexity — same workflow I used when I was <a href="/posts/2026/04/29/chibi-design-system/">researching design systems</a>. I wanted to understand how people actually build good Sudoku apps. Not just “here’s a grid,” but the puzzle generation algorithms, the UX patterns that make a Sudoku app <em>feel</em> right, difficulty calibration, the whole thing.</p>

<p>The research covered puzzle generation approaches, what makes a valid Sudoku (exactly one solution — turns out a lot of cheap apps don’t even guarantee this), how difficulty levels actually work at an algorithmic level, and what features people care about most. Timer, streaks, pencil marks, undo — the basics that every decent Sudoku app needs to not feel broken.</p>

<p>Once I had a solid understanding of the landscape, I took all of that to Claude and started building.</p>

<h2 id="a-web-app-that-pretends-to-be-a-real-app">A web app that pretends to be a real app</h2>

<p>Here’s the thing — I can’t publish an iOS app. Apple charges $99/year for a developer account, and I don’t live in the EU where sideloading is an option. So the move was a <strong>Progressive Web App</strong>. You build a website, add the right meta tags and a service worker, and when you “Add to Home Screen” on iPhone, it looks and behaves like a native app. Full screen, its own icon, no Safari chrome visible.</p>

<p>The stack ended up being React, Vite, and Cloudflare Pages for hosting. I already had my domain (<code class="language-plaintext highlighter-rouge">tgoyal.me</code>) on Cloudflare, so pointing <code class="language-plaintext highlighter-rouge">sudoku.tgoyal.me</code> at a Pages project was trivial. No backend. No database. No accounts. Everything — stats, streaks, settings — lives in <code class="language-plaintext highlighter-rouge">localStorage</code> on the device.</p>

<p>Free. Forever.</p>

<h2 id="what-it-actually-does">What it actually does</h2>

<p>The app generates puzzles algorithmically with four difficulty levels: Easy, Medium, Hard, and Expert. Every puzzle is guaranteed to have exactly one solution. It tracks your streak (consecutive days played), your average completion time, and your best time per difficulty.</p>

<p>It has the features that matter: pencil marks for candidates, undo, a mistake counter, a timer. Light and dark mode, because I play on the train and sometimes the lighting changes. The whole thing is responsive and optimized for iPhone — which is where I use it 95% of the time.</p>

<!-- MEDIA SUGGESTION: A screenshot or side-by-side of the app in light and dark mode on an iPhone would work well here — shows the actual product. -->

<h2 id="the-part-where-it-just-worked">The part where it just… worked</h2>

<p>I keep waiting for the part of this post where I tell you about the three-day debugging nightmare or the API that returned garbage. But honestly? This one went smooth. The puzzle generation algorithm worked on the first real attempt. The PWA setup with Vite’s plugin was mostly plug-and-play. Cloudflare Pages deployed in under a minute.</p>

<p>The hardest part was probably getting iOS-specific quirks right — safe area insets, preventing pull-to-refresh, making sure the viewport didn’t zoom when you tap an input. The kind of stuff that isn’t hard, just <em>annoying</em> and poorly documented.</p>

<h2 id="this-is-the-first-one-not-the-last-one">This is the first one, not the last one</h2>

<p>Here’s the bigger idea. That Sudoku app I was paying for? It’s not the only tool on my phone that’s “free with obnoxious ads.” I use a clipboard manager on my MacBook — basically a notepad that lives in the menu bar. Same deal. Free tier, but with ads wedged into the interface.</p>

<p>I’m already rebuilding it. My own aesthetic, my own keyboard shortcuts, the features <em>I</em> actually want. And when it’s done, I’ll put it out there. Not to make money. Just because if I stumbled onto someone else’s clean, ad-free version of a tool I needed, I’d be grateful.</p>

<p>That’s kind of the play now. Every time an app I rely on starts shoving ads into the experience, I’ll just… build my own. It’s more fun than being annoyed, and I end up with something better anyway.</p>

<p>You can play it right now: <a href="https://sudoku.tgoyal.me">sudoku.tgoyal.me</a></p>

<hr />

<p><em>Built with React, Vite, and Cloudflare Pages. Researched with Perplexity. Developed with Claude. Zero ads, zero subscriptions, zero regrets.</em></p>

<p><em>Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a>.</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="vibe-coding" /><category term="project" /><category term="life" /><summary type="html"><![CDATA[I play Sudoku on my commute. Every day. It’s the one thing that keeps me from doom-scrolling through LinkedIn job posts or reading about whatever Ferrari did wrong this weekend. The app I was using worked fine — until it didn’t.]]></summary></entry><entry><title type="html">I Got Tired of My Apps Looking Like Every Other AI Project, So I Built a Design Language</title><link href="https://tejalgoyal2.github.io/posts/2026/04/29/chibi-design-system/" rel="alternate" type="text/html" title="I Got Tired of My Apps Looking Like Every Other AI Project, So I Built a Design Language" /><published>2026-04-29T00:00:00+00:00</published><updated>2026-04-29T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/04/29/chibi-design-system</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/04/29/chibi-design-system/"><![CDATA[<p>Every vibe-coded app looks the same. You know the one — purple-indigo gradient background, three identical feature cards in a row, a glowing orb that serves no purpose, and Poppins. Always Poppins. I’d been building functional stuff with Claude for weeks, and the <em>logic</em> was great, but every time I looked at the output I thought… <em>this could be anyone’s</em>.</p>

<p>That bothered me more than it should have. So instead of building another app, I spent a weekend building a design system. It’s called <strong>Chibi</strong> — named after my pet sloth (a soft toy, to be clear, I don’t have an exotic animal situation going on). And it’s designed to look nothing like a soft toy.</p>

<h2 id="the-problem-with-default-ai-aesthetics">The problem with default AI aesthetics</h2>

<p>Here’s the thing nobody tells you about vibe coding: the code quality is genuinely impressive. The <em>design</em> quality is aggressively mid. And it’s mid in a very specific, recognizable way.</p>

<p>I started noticing patterns in everything Claude and other models generated for me. Cold blacks and pure whites. Gradient buttons everywhere. Icons sitting inside little colored circles for no reason. That three-column feature grid — icon, bold title, two-line description, repeated three times — which has become the single most recognizable layout pattern in AI-generated interfaces. It’s the equivalent of a stock photo handshake on a corporate website.</p>

<p>The apps <em>worked</em>. They just didn’t feel like <em>mine</em>. If I’m going to build things, I want someone to look at them and think “oh, that’s a Tejal thing” — not “oh, that’s a Claude thing.”</p>

<blockquote>
  <p>The difference between a tool and a product is personality. A spreadsheet is a tool. A spreadsheet that makes you feel something when you open it… okay, that’s still a spreadsheet. But you get the idea.</p>
</blockquote>

<h2 id="how-i-found-my-aesthetic-with-three-different-ais">How I found my aesthetic (with three different AIs)</h2>

<p>I didn’t start with a vision. I started with a vague dissatisfaction and a Perplexity session.</p>

<p>I knew I didn’t want the generic AI look. I knew I wanted dark themes. Beyond that… nothing. So I did what any reasonable person does when they don’t know what they want — I went looking at things until something made me stop scrolling.</p>

<p>I used <a href="https://www.perplexity.ai/">Perplexity</a> to research design approaches for AI-built interfaces. What are people doing to make their projects stand out? What design systems exist? What tools does Claude actually have built-in? The research phase was genuinely useful — I learned about Claude’s <code class="language-plaintext highlighter-rouge">frontend-design</code> skill (which I didn’t know existed), design tokens, anti-pattern lists, and how people structure reusable style systems.</p>

<p>Then I brought the research into GPT 5.4 with thinking enabled and started a conversation that was less “tell me what to do” and more “help me figure out what I actually like.” This is where it got interesting.</p>

<p>GPT ran me through an elimination process. Dark or light? Sharp corners or rounded? Dense or breathing room? Colorful or restrained? Serif or sans-serif? Which brand’s visual vibe resonates — Linear, Stripe, Vercel, Apple, Notion?</p>

<p>I couldn’t pick one. But I could <em>eliminate</em>.</p>

<p>Apple? Too plain. Raycast? No real design in my opinion. Vercel? Too dark and austere. Figma? Looks like a PowerPoint scroll. But Notion’s use of black and white — yes. Linear’s transitions and placement — yes. Stripe’s polish — fine but not <em>it</em>.</p>

<p>Then it asked me for reference sites. And <em>that’s</em> when I figured it out.</p>

<p><a href="https://www.flyhyer.com/">Flyhyer.com</a> — that plane that pushes forward, the boldness of the type, the confidence. <em>That.</em></p>

<p><a href="https://unseen.co/">Unseen.co</a> — the serif-sans contrast, the cinematic warmth, the way the type alone creates drama. <em>Also that.</em></p>

<p>And then GPT said something that made it click: “Your style in one sentence: Dark-warm cinematic minimalism — bold high-contrast serif display type, generous breathing room, near-black surfaces with off-white and one warm accent, smooth transitions, no clutter, feels expensive.”</p>

<p>I read it twice. <em>That’s it. That’s the thing.</em></p>

<h2 id="the-font-revelation">The font revelation</h2>

<p>Let me rant about fonts for a second.</p>

<p>I kept telling GPT “I’m seeing some fonts where the lines get thin and thick in the corners, I think I like them.” Very technical description, I know. Turns out what I was describing is a <strong>high-contrast serif</strong> — fonts where the strokes swell from dramatically thin hairlines to thick weight at the curves and corners. Think Cormorant Garamond, Playfair Display, Editorial New.</p>

<p>The moment I saw Cormorant Garamond at display scale on a dark background, I knew. It’s architectural. It feels like someone carved it into the side of a building. Paired with Satoshi (a clean geometric sans-serif from <a href="https://www.fontshare.com/">Fontshare</a>) for body text, the contrast between the two creates this… tension. Editorial meets engineering. Drama meets clarity.</p>

<p>Every single AI-generated site I’d seen used Space Grotesk, Inter, or Poppins. Picking a serif display font was, weirdly, a design statement by itself. It’s the typographic equivalent of showing up to a hackathon in a blazer.</p>

<h2 id="from-vibes-to-a-system">From vibes to a system</h2>

<p>Having an aesthetic is one thing. Making it <em>repeatable</em> is another.</p>

<p>I needed this to work across every future project without re-explaining my preferences each time. The answer was a <strong>Claude Skill</strong> — a structured file that lives in Claude’s context and automatically enforces the design system whenever I ask for anything visual.</p>

<p>I took the full design direction from my Perplexity and GPT sessions and brought it to Claude to build the actual skill. This is where the division of labor made sense — GPT was great for the exploratory “who am I as a designer” conversation, but Claude’s skill system is what makes the decisions <em>stick</em>.</p>

<p>The <a href="https://github.com/tejalgoyal2/chibi-design-system">skill</a> ended up with a lean structure — one instruction file and three reference files:</p>

<p><strong><code class="language-plaintext highlighter-rouge">SKILL.md</code></strong> — the brain. Design philosophy, workflow rules, the quality test every project must pass before shipping. About 84 lines. Lean on purpose — if the instruction file is bloated, the model reads it slower and follows it worse. I learned <em>that</em> lesson the hard way with my <a href="/posts/2026/04/03/ai-resume-system/">resume system</a>.</p>

<p><strong><code class="language-plaintext highlighter-rouge">references/tokens.md</code></strong> — the complete CSS variable system. Every color, every spacing value, every shadow, every font declaration. Dark mode and light mode. This is the source of truth — if a value isn’t defined here, it doesn’t exist in Chibi.</p>

<p><strong><code class="language-plaintext highlighter-rouge">references/components.md</code></strong> — how buttons, cards, inputs, and the signature “heading moment” should look and behave. Motion patterns, easing curves, hover states.</p>

<p><strong><code class="language-plaintext highlighter-rouge">references/anti-patterns.md</code></strong> — the blacklist. Gradient buttons? Banned. Purple glow orbs? Banned. Icons in colored circles? <em>Extremely</em> banned. Poppins? I never want to see it again. This file exists so Claude knows what <em>not</em> to do, which turns out to be just as important as knowing what to do.</p>

<h2 id="the-chibi-system-in-a-nutshell">The Chibi system in a nutshell</h2>

<p>The whole thing comes down to a few core principles:</p>

<p><strong>Typography is the design.</strong> Before any color, image, or layout decision, the type should already be doing most of the work. One moment per page where Cormorant Garamond goes big — really big — and everything else steps back. That’s the “Hyer Principle.” One moment where you mix roman and italic serif for contrast — that’s the “Unseen Studio Principle.” After that, Satoshi handles everything else and stays out of the way.</p>

<p><strong>Color restraint is the accent.</strong> The palette is warm near-blacks (<code class="language-plaintext highlighter-rouge">#0f0e0d</code>, not cold <code class="language-plaintext highlighter-rouge">#000000</code>), layered dark surfaces that get slightly lighter as they elevate, and off-white text (<code class="language-plaintext highlighter-rouge">#f0ede8</code>, not screaming <code class="language-plaintext highlighter-rouge">#ffffff</code>). The accent is a warm cream-gold (<code class="language-plaintext highlighter-rouge">#e8dcc8</code>) — and it only appears on the <em>single most important interactive element on screen</em>. Everything else signals interactivity through border weight changes and surface tone shifts. If everything is accented, nothing is.</p>

<p><strong>Space directs attention.</strong> More space around the important thing. Less space between related things. Never the same padding on every section — that’s how you get a page that reads like a list instead of a story.</p>

<p><strong>Motion breathes.</strong> Elements fade in with a gentle 16px upward drift. Hover transitions take 180ms with a specific easing curve (<code class="language-plaintext highlighter-rouge">cubic-bezier(0.16, 1, 0.3, 1)</code> — fast in, gentle settle). No bouncing. No spinning. If an animation draws attention to itself, it’s wrong.</p>

<h2 id="default-claude-vs-chibi--same-content-different-universe">Default Claude vs. Chibi — same content, different universe</h2>

<p>To see the difference, I had Claude generate two versions of the same page — a personal project landing page with identical content. One using its default <code class="language-plaintext highlighter-rouge">frontend-design</code> aesthetic. One using Chibi. <a href="/assets/demos/compare.html"><strong>See them side-by-side here.</strong></a></p>

<p>The default version came out with cold dark blues, a purple accent, floating gradient orbs in the background, and card hover effects that glowed. It looked fine. It looked like every other AI-generated portfolio page on the internet.</p>

<p>The Chibi version used warm near-black surfaces, Cormorant Garamond at hero scale with one italic word for drama, cream-gold accent on just the primary button, and cards that signal hover through a subtle border shift instead of a glow. It looked like it was <em>designed</em>. By a person. With opinions.</p>

<p>Same code complexity. Same content. Completely different feeling. That’s what a design system buys you — not fancier technology, just <em>intentional</em> decisions applied consistently.</p>

<h2 id="the-five-question-test">The five-question test</h2>

<p>Every Chibi project has to pass five questions before I’ll ship it:</p>

<p><strong>The double-take test.</strong> Would someone scrolling past stop and look twice? If no, something needs more confidence.</p>

<p><strong>The attribution test.</strong> Could this belong to any other AI-generated project? If yes, it has failed. <em>This is the one that matters most.</em></p>

<p><strong>The material test.</strong> Does it feel like a premium physical object — a matte black notebook, a brushed metal surface? If it feels plasticky, revisit the palette.</p>

<p><strong>The breathing room test.</strong> Remove one element. Does the page feel better? If yes, remove it permanently.</p>

<p><strong>The type test.</strong> Cover all colors and images. Does the typography alone look intentional? If the page is ugly without color, the type hierarchy needs work.</p>

<h2 id="what-i-actually-learned">What I actually learned</h2>

<p>This whole thing took a weekend. Not a month. Not a “design bootcamp.” One Perplexity session, one long GPT conversation, and one Claude skill-building chat. The design system is done. It applies automatically to every project I build now.</p>

<p>The biggest lesson wasn’t about design — it was about <em>using the right model for the right phase</em>. Perplexity was perfect for research. GPT with thinking was perfect for the exploratory “what do I even want” conversation — it asked the right questions and synthesized my messy preferences into a coherent direction. Claude was perfect for turning that direction into a structured, reusable system. No single model did the whole job. They were a relay team, and the baton passes were the interesting part.</p>

<p>The other lesson: knowing what you <em>don’t</em> want is almost as useful as knowing what you do. I couldn’t describe my ideal design language from scratch. But I could point at things and say “not that.” Enough “not thats” eventually leave you standing on the one thing that’s <em>yes</em>.</p>

<h2 id="whats-next">What’s next</h2>

<p>I’m starting a software engineering co-op next week — which means the side project velocity is about to drop from “every few days” to “whenever I’m not already staring at code for eight hours.” But the design system goes with me. Every personal project, every portfolio piece, every random weekend build — it all runs through Chibi now.</p>

<p>The <a href="https://github.com/tejalgoyal2/chibi-design-system">skill is on GitHub</a> if you want to see how it’s structured. And if you want to build your own — you should. Not because my aesthetic is right for you (it almost certainly isn’t), but because having <em>an</em> aesthetic that’s consistently yours is the difference between a portfolio and a pile of projects.</p>

<blockquote>
  <p>Chibi — Named after a soft toy sloth. Designed to look nothing like a soft toy.</p>
</blockquote>

<hr />

<p><em>Built with Perplexity, GPT 5.4 with thinking, and Claude · April 2026</em></p>

<p><em>Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a> — I promise my messages are more concise than my blog posts.</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><category term="project" /><summary type="html"><![CDATA[Every vibe-coded app looks the same. You know the one — purple-indigo gradient background, three identical feature cards in a row, a glowing orb that serves no purpose, and Poppins. Always Poppins. I’d been building functional stuff with Claude for weeks, and the logic was great, but every time I looked at the output I thought… this could be anyone’s.]]></summary></entry><entry><title type="html">I Built an Interactive Attack Path Visualizer Because Spreadsheets Aren’t Scary Enough</title><link href="https://tejalgoyal2.github.io/posts/2026/04/14/iam-threat-mapper/" rel="alternate" type="text/html" title="I Built an Interactive Attack Path Visualizer Because Spreadsheets Aren’t Scary Enough" /><published>2026-04-14T00:00:00+00:00</published><updated>2026-04-14T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/04/14/iam-threat-mapper</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/04/14/iam-threat-mapper/"><![CDATA[<p>During my cybersecurity co-op I spent a lot of time staring at IAM configurations. Access policies, MFA enforcement gaps, privileged account sprawl, the whole identity stack. And the thing that kept bugging me wasn’t any single misconfiguration — it was that nobody could <em>see</em> how they chained together.</p>

<p>A weak MFA policy on its own? Manageable. That same weak MFA policy connected to a privileged service account connected to a VPN gateway connected to production infrastructure? That’s a breach path. And it’s invisible in a spreadsheet.</p>

<p>So I built <a href="https://iam.tgoyal.me">IAM Threat Mapper</a> — an interactive tool that visualizes identity-based attack chains and maps them to the MITRE ATT&amp;CK framework. You can see how a SIM swap leads to MFA bypass leads to privilege escalation leads to data exfiltration… as a graph. With nodes. And edges. And colors that mean things.</p>

<p>It’s the tool I wished I had at work. So I built it on the side.</p>

<h2 id="why-identity-attacks-specifically">Why identity attacks specifically</h2>

<p>Here’s the thing about modern breaches — the interesting ones almost never start with some zero-day exploit or sophisticated malware. They start with <em>identity</em>.</p>

<p>The <a href="https://www.cisa.gov/news-events/cybersecurity-advisories">MGM Resorts breach</a>? Started with a helpdesk social engineering call. Someone called the helpdesk, pretended to be an employee, got a password reset. From there: lateral movement, privilege escalation, ransomware. Billions in damages. The initial entry point was a <em>phone call</em>.</p>

<p>The Uber breach? A contractor’s credentials were compromised. The attacker spammed MFA push notifications until the contractor approved one out of frustration — a technique called MFA fatigue. Once inside, the attacker found hardcoded credentials in a script and pivoted to everything.</p>

<p>SolarWinds? Supply chain compromise, sure. But the <em>lateral movement</em> inside victim networks was all identity-based. Compromised tokens, forged SAML assertions, privilege escalation through identity federation trust.</p>

<p>The pattern is always the same: gain an identity foothold, escalate privileges, move laterally. And the defenses that matter — MFA enforcement, privileged access management, conditional access policies, session controls — are all identity controls.</p>

<p>I was seeing this pattern every day in my co-op work. Investigating access anomalies, reviewing IAM policies, triaging alerts from the identity platform. The attack paths were real. The data was right there. But there was no good way to <em>show</em> someone — a manager, a stakeholder, a new team member — how a chain of small weaknesses becomes one big problem.</p>

<h2 id="the-two-halves-of-the-tool">The two halves of the tool</h2>

<p>IAM Threat Mapper does two things, and they’re designed to work together.</p>

<h3 id="attack-path-visualizer">Attack path visualizer</h3>

<p>This is the flashy part. An interactive node graph — built with <a href="https://js.cytoscape.org/">Cytoscape.js</a> — that shows how real-world identity attacks unfold step by step. Each node is a stage in the attack chain (initial access, credential theft, privilege escalation, lateral movement, impact). Each edge is the technique that connects them, mapped to a specific <a href="https://attack.mitre.org/">MITRE ATT&amp;CK</a> technique ID.</p>

<p>You can click on an attack scenario — SIM swap, OAuth token theft, helpdesk social engineering, MFA fatigue, federation abuse — and watch the path light up. Each node expands to show what happened, what MITRE technique applies, and what defensive control could have stopped it.</p>

<p>The goal isn’t just “look, a pretty graph.” It’s to answer the question security teams actually care about: <em>where does this chain break if we fix one thing?</em> If you enforce phishing-resistant MFA, the MFA fatigue path dies at node two. If you implement privileged access management, the lateral movement path dies at node four. The graph makes the ROI of specific controls <em>visible</em>.</p>

<h3 id="iam-maturity-assessment">IAM maturity assessment</h3>

<p>The other half is a questionnaire — a structured self-assessment that walks through the major IAM control categories: authentication strength, privileged access management, lifecycle governance, monitoring and detection, conditional access, and a few others.</p>

<p>Each category has pointed questions. Not “do you have MFA?” but “is MFA enforced for <em>all</em> user types including service accounts and break-glass accounts?” Not “do you review access?” but “do you have automated access certification campaigns with defined recertification windows?”</p>

<p>The assessment generates a maturity score per category and an overall score. It’s not meant to replace a proper audit — it’s meant to give a team a quick snapshot of where they are and, more importantly, where the <em>gaps</em> are. The gaps are where the attack paths live.</p>

<blockquote>
  <p>The two halves are connected by design. A low maturity score in “Authentication Strength” maps directly to the attack scenarios that exploit weak authentication. The assessment tells you <em>what’s weak</em>. The visualizer tells you <em>what happens when it’s exploited</em>. Together, they make the case for fixing it.</p>
</blockquote>

<h2 id="the-tech-decisions">The tech decisions</h2>

<p><strong>React 19 with Cytoscape.js</strong> for the graph visualization. I looked at D3 first — it’s the standard for data visualization in JavaScript — but Cytoscape is purpose-built for network graphs. It handles node positioning, edge routing, zoom, pan, and layout algorithms out of the box. For a graph where the <em>relationships between nodes</em> are the whole point, Cytoscape was the right call. D3 would have meant building all of that from scratch.</p>

<p><strong>Tailwind CSS v3</strong> for styling. I didn’t want to fight CSS while also fighting graph layout algorithms. Tailwind let me move fast without making everything look like a Bootstrap template from 2019.</p>

<p><strong>No backend.</strong> All logic runs client-side. All data is static JSON. The attack scenarios, the assessment questions, the MITRE mappings — it’s all bundled into the React app. This was a deliberate choice: I wanted this to be something anyone could open in a browser without creating an account, without sending data to a server, without any privacy concerns. You’re assessing your <em>security posture</em> — the tool that helps you do that shouldn’t be collecting your answers.</p>

<p><strong>Cloudflare Pages</strong> for hosting. Free, fast, deploys from a GitHub push. The whole app is a static site — no server-side rendering, no API calls, no database. Build it, push it, done.</p>

<p><strong>No external UI libraries.</strong> Zero Bootstrap, zero Material UI, zero component libraries. Every element is hand-styled with Tailwind. This is partially stubbornness and partially because I wanted full control over how the graph and assessment panels interact visually. When your main feature is a complex interactive graph, you don’t want a component library’s opinions about layout fighting your opinions about layout.</p>

<h2 id="building-the-attack-scenarios">Building the attack scenarios</h2>

<p>This was the part that took the most time and the most thought. The code was straightforward — React components rendering Cytoscape graphs. The <em>content</em> was the hard part.</p>

<p>Each attack scenario needed to be:</p>

<ol>
  <li>
    <p><strong>Based on a real breach.</strong> Not hypothetical. Not “imagine if someone…” Real incidents with public reporting. MGM, Uber, SolarWinds, and others where the attack chain is well-documented.</p>
  </li>
  <li>
    <p><strong>Mapped to MITRE ATT&amp;CK.</strong> Every step in the chain needed a real technique ID — T1078 (Valid Accounts), T1556 (Modify Authentication Process), T1098 (Account Manipulation), and so on. This grounds the scenarios in an industry-standard framework, not my personal opinion about what’s scary.</p>
  </li>
  <li>
    <p><strong>Actionable.</strong> Each node needed to show not just “what happened” but “what would have stopped this.” If the answer to “how do we prevent this step” is “implement phishing-resistant MFA” — that’s specific enough for someone to act on. If the answer is “be more secure” — that’s useless.</p>
  </li>
</ol>

<p>Building this meant reading a <em>lot</em> of breach reports, CISA advisories, and threat intelligence writeups. Then distilling each incident into a clean chain of 5-7 nodes that tells the story without drowning in detail. It’s a weird kind of editing — taking a complex, messy, real-world incident and turning it into a graph that a security analyst can absorb in thirty seconds.</p>

<p>I… genuinely enjoyed this part. Reading about how attackers chain identity weaknesses together is <em>fascinating</em> in the worst way. Like watching a heist movie where the vault is your company’s production environment.</p>

<h2 id="what-i-learned-building-it">What I learned building it</h2>

<p><strong>Graph layout is a rabbit hole.</strong> Cytoscape has multiple layout algorithms — breadthfirst, dagre, cose, grid. Each one arranges the same nodes differently. I spent an embarrassing amount of time switching between them, squinting at the screen, and going “no, that edge crosses that other edge and now it looks like step 3 leads to step 5 when it doesn’t.” Dagre (directed acyclic graph layout) ended up being the winner for attack paths because they’re inherently directional — you move left to right through the kill chain.</p>

<p><strong>Assessment questions are harder to write than code.</strong> A bad question gives you a useless answer. “Do you have identity monitoring?” — what does that even mean? Do you mean you have logs? Do you mean you have alerts? Do you mean someone <em>looks</em> at the alerts? Each question went through multiple rewrites to be specific enough to produce a meaningful maturity signal.</p>

<p><strong>Static data is underrated.</strong> No backend means no auth, no database migrations, no API versioning, no server costs, no security surface to worry about. The entire app is a folder of HTML, CSS, and JavaScript. If I want to add a new attack scenario, I add a JSON object and push to GitHub. Fifteen seconds. If this had a backend, adding a scenario would mean a migration, a deployment, and probably a prayer.</p>

<p><strong>Building from work experience is a cheat code.</strong> I didn’t have to guess what IAM weaknesses matter — I’d been looking at them every day for months. The assessment categories came directly from the gaps I saw in real environments. The attack scenarios came from the incident reports I was reading as part of my actual job. The tool is better because I built it <em>while</em> doing the work it’s about, not after.</p>

<h2 id="try-it">Try it</h2>

<p>It’s live at <a href="https://iam.tgoyal.me">iam.tgoyal.me</a>. The code is on <a href="https://github.com/tejalgoyal2/iam-threat-mapper">GitHub</a>. Click through an attack scenario, run the assessment, poke around.</p>

<p>If you’re in security and you think a category is missing from the assessment, or an attack path could be more accurate, or the MITRE mapping is wrong somewhere — I want to hear about it. This is a living project. It gets better when people who know more than me tell me what I got wrong.</p>

<p>And if you’re a student or early-career security person thinking about building a portfolio project… build the thing you wish existed at work. Not a tutorial project. Not a clone of something that already exists. The thing that would have made your Tuesday afternoon easier. That’s the project that teaches you the most and looks the best on a resume.</p>

<p>Trust me. I built a <a href="/posts/2026/04/03/ai-resume-system/">whole system</a> for generating those resumes. I know what looks good on them.</p>

<hr />

<p><em>Built with React, Cytoscape.js, and too many hours reading breach reports · <a href="https://github.com/tejalgoyal2/iam-threat-mapper">GitHub</a> · April 2026</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="security" /><category term="project" /><summary type="html"><![CDATA[During my cybersecurity co-op I spent a lot of time staring at IAM configurations. Access policies, MFA enforcement gaps, privileged account sprawl, the whole identity stack. And the thing that kept bugging me wasn’t any single misconfiguration — it was that nobody could see how they chained together.]]></summary></entry><entry><title type="html">The Resume System Worked. So Naturally, I Broke It Trying to Make It Better.</title><link href="https://tejalgoyal2.github.io/posts/2026/04/11/optimizing-ai-resume-system/" rel="alternate" type="text/html" title="The Resume System Worked. So Naturally, I Broke It Trying to Make It Better." /><published>2026-04-11T00:00:00+00:00</published><updated>2026-04-11T00:00:00+00:00</updated><id>https://tejalgoyal2.github.io/posts/2026/04/11/optimizing-ai-resume-system</id><content type="html" xml:base="https://tejalgoyal2.github.io/posts/2026/04/11/optimizing-ai-resume-system/"><![CDATA[<p>I wrote a whole post about <a href="/posts/2026/04/03/ai-resume-system/">building an AI resume system</a> that took five versions to get right. Five versions. Weeks of iteration. A companion <a href="/posts/2026/04/05/build-your-own-ai-resume-pipeline/">how-to guide</a> and everything. I was <em>done</em>. The system worked. Resumes came out clean, one page, no orphan lines. I could paste a job description and have a tailored <code class="language-plaintext highlighter-rouge">.docx</code> in under a minute.</p>

<p>I should have stopped there.</p>

<p>…I did not stop there.</p>

<h2 id="the-problem-i-didnt-know-i-had">The problem I didn’t know I had</h2>

<p>Here’s the thing about Claude Pro — you get a usage allowance that resets every five hours. And I’d been generating resumes without really paying attention to how much each one cost. Why would I? It worked. The output was good. Life was fine.</p>

<p>Then one afternoon I generated a single resume and watched <em>ten percent</em> of my five-hour allowance disappear.</p>

<p>Ten percent. For one resume. One page. Maybe eighty lines of actual output.</p>

<p>I checked the previous week’s usage. The same skill had been costing 3-4% per run. Something had changed, and I hadn’t noticed because I was too busy admiring my beautiful one-page resumes to look at the meter.</p>

<blockquote>
  <p>It’s like driving a car that gets great mileage and then one day you notice the fuel gauge dropping twice as fast. The car still drives fine. The destination is the same. But something under the hood is <em>wrong</em>, and now you can’t un-see it.</p>
</blockquote>

<h2 id="the-investigation">The investigation</h2>

<p>I pulled up the chat transcript from the last generation and started counting tool calls. A “tool call” is every time the model reads a file, writes a file, runs a script, or executes a command. Each one costs tokens. Tokens cost usage.</p>

<p>The count: <strong>thirty-five tool calls</strong> for a single resume.</p>

<p>Thirty-five.</p>

<p>I stared at the transcript. The model was reading every reference file — some of them twice. It was reading the master resume, then reading the rules, then reading the master resume <em>again</em> because the rules referenced something it wanted to double-check. It was running the build script, hitting a validation error, fixing the error, running the script again, hitting a <em>different</em> validation error, fixing <em>that</em>, running it a third time…</p>

<p>Each read, each write, each script execution — a tool call. Each tool call — tokens. Each token — usage. Thirty-five of them stacking up like a bar tab you forgot to close.</p>

<p>The model was doing exactly what I’d told it to do. The problem wasn’t the model. The problem was that my instructions sent it on a scavenger hunt across seven files before it could write a single line of output.</p>

<h2 id="version-6-fewer-files-fewer-reads">Version 6: Fewer files, fewer reads</h2>

<p>The first fix was straightforward — stop making the model read things it doesn’t need.</p>

<p>I had rules duplicated across three files: the SKILL.md instructions, a separate rules reference document, and embedded inside comments in the master resume data files themselves. The model was reading all three, sometimes finding slightly different phrasings of the same rule, and spending tokens reconciling them.</p>

<p>Sound familiar? This was the same duplication problem I thought I’d solved in version 5. I had. For the <em>content</em>. But the meta-instructions — the “how to use this skill” preamble, the “remember to check character counts” reminders — had crept back in. Like weeds. You pull them and they grow back in a different file.</p>

<p>I gutted everything. One instruction file. One. The master resumes became pure data — no comments, no guidance, no “when tailoring, consider…” blocks. The reference file got slimmed to just a verb list. Nothing else.</p>

<p>Tool calls dropped from 35 to about 20. Better. Not great. The model was still running the validator, failing, fixing, and re-running multiple times.</p>

<h2 id="version-61-the-validate-then-build-loop">Version 6.1: The validate-then-build loop</h2>

<p>The validation script and the build script were separate files. The workflow was: model writes data → model runs validator → validator prints errors → model fixes errors → model runs validator again → if clean, model runs build script → build script generates <code class="language-plaintext highlighter-rouge">.docx</code>.</p>

<p>Every run of the validator was a tool call. Every run of the build script was a tool call. A resume with three validation errors meant three validator runs plus one build run — four tool calls just for the “check and compile” phase. And the model had to read the validator output, interpret it, make changes, and try again each time.</p>

<p>The fix was merging them. One script: <code class="language-plaintext highlighter-rouge">validate_and_build.js</code>. It validates <em>and</em> builds in a single execution. If validation fails, it prints the errors and stops — no <code class="language-plaintext highlighter-rouge">.docx</code>. If validation passes, it builds immediately. One tool call for the whole cycle.</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Before: validate → fix → validate → fix → validate → build  (6 calls)
After:  validate_and_build → fix → validate_and_build        (2 calls)
</code></pre></div></div>

<p>The validator itself got smarter too. Hard fails for the things that actually break resumes: bullets over 210 characters, em dashes (which render inconsistently in <code class="language-plaintext highlighter-rouge">.docx</code>), duplicate action verbs across bullets, and missing required fields. Soft warnings for the orphan danger zone — bullets between 106 and 189 characters that <em>might</em> wrap badly but aren’t guaranteed to. The model sees the warnings but doesn’t have to fix them to get a build.</p>

<p>This was the version where it finally clicked that validation errors aren’t just quality checks — they’re <em>token costs</em>. Every error the model has to fix is another round trip. Catching more issues on the first pass means fewer iterations means fewer tool calls means less usage. Quality and efficiency pointing in the same direction.</p>

<p>…which sounds obvious written down. But it took me two versions to figure out. Classic.</p>

<h2 id="version-7-eight-tool-calls">Version 7: Eight tool calls</h2>

<p>Version 7 was the cleanup pass. The SKILL.md got rewritten to be more explicit about the workflow — not “here are some guidelines” but “do these steps in this order, do not deviate.”</p>

<p>The model’s job became almost mechanical:</p>

<ol>
  <li>Read the job description (already in context — zero tool calls)</li>
  <li>Read the right master resume (one tool call)</li>
  <li>Write <code class="language-plaintext highlighter-rouge">resume_data.js</code> (one tool call)</li>
  <li>Copy <code class="language-plaintext highlighter-rouge">validate_and_build.js</code> to working directory (one tool call)</li>
  <li>Run it (one tool call)</li>
  <li>If errors, fix and re-run (one-two more tool calls)</li>
  <li>Copy final <code class="language-plaintext highlighter-rouge">.docx</code> to output (one tool call)</li>
</ol>

<p>Total: <strong>roughly eight tool calls</strong>. Down from thirty-five. The usage went from 10% back to about 3%.</p>

<p>I was… unreasonably proud of this. Like “told multiple people about it at dinner” proud. Nobody cared. They were right not to care. But <em>I</em> cared. The numbers were beautiful.</p>

<h2 id="version-71-the-one-line-patch">Version 7.1: The one-line patch</h2>

<p>And then the very next resume I generated broke.</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Error: Cannot find module './resume_data.js'
</code></pre></div></div>

<p>The build script couldn’t find the data file. But the data file was <em>right there</em>. I could see it. In the directory. Existing. Being a file. Doing file things.</p>

<p>The problem: the model was running the script from a different working directory than where it wrote the data file. <code class="language-plaintext highlighter-rouge">validate_and_build.js</code> was looking for <code class="language-plaintext highlighter-rouge">./resume_data.js</code> relative to wherever <code class="language-plaintext highlighter-rouge">node</code> was invoked from — not relative to where the script lived.</p>

<p>The fix was one line:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nx">process</span><span class="p">.</span><span class="nf">chdir</span><span class="p">(</span><span class="dl">"</span><span class="s2">/home/claude</span><span class="dl">"</span><span class="p">);</span>
</code></pre></div></div>

<p>At the top of the script. Before anything else runs. Forces Node to operate from the right directory regardless of where the model invokes it from.</p>

<p>One line. That’s v7.1. That’s the entire changelog. I almost didn’t version-bump it. But a fix that prevents a guaranteed failure on certain invocation paths felt like it deserved a number.</p>

<h2 id="the-part-where-i-try-to-be-philosophical-about-this">The part where I try to be philosophical about this</h2>

<p>There’s a version of this story where I say something wise about knowing when to stop. About how v5 was good enough and the rest was vanity. About how the real lesson is being happy with what you have.</p>

<p>…and honestly, there’s truth in that. V5 worked. The resumes were good. If I’d stopped there, I’d have more free time and the same career outcomes.</p>

<p>But v7 uses a quarter of the tokens. The resumes build in one pass instead of three. The error messages are clearer. The whole system is <em>tighter</em> — and I understand it better because I tore it apart and rebuilt it. Twice.</p>

<p>So I don’t know. Maybe the lesson is that optimization is its own kind of building. Or maybe the lesson is that I will always find a reason to keep tinkering when I should be applying to jobs. One of those. Probably both.</p>

<p>There goes my career as a motivational speaker.</p>

<h2 id="the-numbers">The numbers</h2>

<table>
  <thead>
    <tr>
      <th>Version</th>
      <th>Tool calls</th>
      <th>Usage per resume</th>
      <th>What changed</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>v4-v5</td>
      <td>~35</td>
      <td>~10%</td>
      <td>Worked, but expensive</td>
    </tr>
    <tr>
      <td>v6</td>
      <td>~20</td>
      <td>~6%</td>
      <td>Deduplicated rules, fewer file reads</td>
    </tr>
    <tr>
      <td>v6.1</td>
      <td>~14</td>
      <td>~4%</td>
      <td>Merged validate + build scripts</td>
    </tr>
    <tr>
      <td>v7</td>
      <td>~8</td>
      <td>~3%</td>
      <td>Explicit workflow, minimal reads</td>
    </tr>
    <tr>
      <td>v7.1</td>
      <td>~8</td>
      <td>~3%</td>
      <td>One-line working directory fix</td>
    </tr>
  </tbody>
</table>

<p>If you want to see how the system was built from scratch, the <a href="/posts/2026/04/05/build-your-own-ai-resume-pipeline/">companion guide</a> covers the architecture. This post is the sequel nobody asked for — the part where a working system gets faster for reasons that only matter to the person paying the token bill.</p>

<p>Which is me. So it matters to me.</p>

<hr />

<p>Find me on <a href="https://linkedin.com/in/tejalgoyal">LinkedIn</a> — especially if you’re hiring. My resume was generated by a system that took eight versions to build, and it’ll arrive in your inbox in under thirty seconds. The system, not me. I take longer.</p>

<p><em>Optimized with Claude Skills and an unhealthy attention to tool call counts · April 2026</em></p>]]></content><author><name>Tejal Goyal</name></author><category term="dev" /><category term="vibe-coding" /><summary type="html"><![CDATA[I wrote a whole post about building an AI resume system that took five versions to get right. Five versions. Weeks of iteration. A companion how-to guide and everything. I was done. The system worked. Resumes came out clean, one page, no orphan lines. I could paste a job description and have a tailored .docx in under a minute.]]></summary></entry></feed>