DEV Community: member_ce2645ea

I Analyzed 200 Rejection Emails and Built an AI That Fixes Resumes

member_ce2645ea — Thu, 25 Jun 2026 12:57:17 +0000

Last year I was laid off. Like a lot of people, I sent out hundreds of applications. Unlike most people, I saved every rejection email and tried to figure out what was actually happening.

The result was a rabbit hole that ended with me building a resume analyzer. Here's what I found.

The Real Problem Isn't Your Resume

After reading 200+ rejections (yes, I kept a spreadsheet), I noticed a pattern. The companies that actually interviewed me didn't have better resumes — they had resumes that matched their specific job description better.

Most resume advice is generic: "use action verbs," "keep it to one page," "quantify your impact." That advice is fine, but it misses the point. The goal isn't a good resume. The goal is a resume that passes the specific filter of a specific job at a specific company.

How the Analyzer Works

The approach is simple: compare a resume against a job description and measure the overlap across four dimensions:

function scoreResume(resumeText, jobDescription) {
  const keywords = extractKeywords(jobDescription)
  const matched = keywords.filter(k =>
    resumeText.toLowerCase().includes(k.toLowerCase())
  )
  return {
    matchRate: (matched.length / keywords.length) * 100,
    missingKeywords: keywords.filter(k =>
      !resumeText.toLowerCase().includes(k.toLowerCase())
    ),
    keywordDensity: keywords.length / resumeText.split(' ').length,
  }
}

The keyword extraction strips common words and pulls out the meaningful terms: technologies, certifications, industry-specific phrases. If the JD mentions "Kubernetes" three times and your resume doesn't mention it once, that's a problem — regardless of whether you think you can learn it on the job.

What Surprised Me

Two things:

Soft skills are invisible to filters. "Great communicator" and "team player" mean nothing to an ATS parser. The system is looking for concrete terms.
The same resume can score 20% against one JD and 80% against another. The difference isn't you — it's how well your wording overlaps with what they're asking for.

Run Your Own Resume Check

The tool I built is at resumeaiopt.com. Paste your resume and a job description, and it'll show you where the gaps are. No account needed, no data stored — just analysis.

Why I Stopped Proofreading Manually and Built a Grammar Checker Instead

member_ce2645ea — Thu, 25 Jun 2026 12:54:11 +0000

I was that person who would write a single email, read it eight times, still hit send, and immediately spot a typo. Every. Single. Time.

Writing is hard enough without having to also be your own copy editor. After spending way too much time proofreading blog posts, work emails, and even Slack messages, I decided to automate at least the mechanical part of it.

What Most Grammar Checkers Get Wrong

The existing tools I tried had two problems:

First, they were too opinionated. Grammarly would tell me to rewrite half my sentence because of some stylistic preference. I don't need suggestions — I need to know if I wrote "their" when I meant "there."

Second, they wanted too much access. Browser extensions reading everything you type? No thanks. I wanted something I could paste text into, get a clean report, and leave.

Building a Minimal Grammar Check

The core approach is straightforward: break the text into sentences, check each one against known patterns, flag the matches. Here's the sentence splitter I ended up using:

function splitSentences(text) {
  return text
    .replace(/([.?!])\s+/g, '$1\n')
    .split('\n')
    .filter(s => s.trim().length > 0)
}

Simple regex splitting handles most cases. The hard part was the pattern library — things like subject-verb agreement, common homophone mistakes, and punctuation rules. Each rule is just a function that takes a sentence and returns a list of issues:

function checkHomophones(sentence) {
  const rules = [
    { pattern: /\btheir\b(?=\s+(?:going|not|is|are))/i, message: 'Did you mean "they\'re"?' },
    { pattern: /\byoure\b/i, message: 'Did you mean "you\'re"?' },
  ]
  return rules
    .filter(r => r.pattern.test(sentence))
    .map(r => ({ type: 'homophone', message: r.message }))
}

What I Learned

The biggest insight was that most writing errors fall into a small set of patterns. You don't need a machine learning model to catch 80% of mistakes. A well-crafted ruleset catches the common stuff, and for the remaining 20%, you should probably just read it yourself.

Also, the tool helped me write better over time. When you see the same mistake flagged repeatedly, you eventually stop making it.

Check Your Own Writing

The tool I built is at grammaraicheck.com — paste your text, get instant feedback on grammar, spelling, and punctuation. No signup, no data collection, just a text box and a red underline.

How I Built a DCA Calculator to Understand Dollar Cost Averaging

member_ce2645ea — Thu, 25 Jun 2026 12:54:09 +0000

I've been putting money into the stock market for about three years now. Nothing fancy — just S&P 500 ETFs, auto-invest every month, same amount regardless of what the market is doing. That's dollar cost averaging in a nutshell.

But for the first year, I kept second-guessing myself. "Should I wait for a dip?" "Should I put in a lump sum instead?" I wanted to see, with actual numbers, whether DCA actually made sense in different scenarios.

So I built a calculator.

What Dollar Cost Averaging Actually Does

DCA means you invest a fixed amount of money at regular intervals. When the price is high, you buy fewer shares. When it's low, you buy more. Over time, your average cost per share ends up lower than the average price per share during the same period.

That sounds like magic until you run the numbers yourself. Here's the core logic I used:

function dcaSimulation(monthlyInvestment, monthlyPrices) {
  let totalShares = 0
  let totalInvested = 0

  monthlyPrices.forEach((price) => {
    const shares = monthlyInvestment / price
    totalShares += shares
    totalInvested += monthlyInvestment
  })

  const finalValue = totalShares * monthlyPrices[monthlyPrices.length - 1]
  const avgCost = totalInvested / totalShares

  return { totalInvested, finalValue, avgCost, totalShares }
}

Simple math. But seeing the output for different price patterns — steady growth, volatile flat, crash then rebound — was way more convincing than reading blog posts about it.

The Feature That Changed My Mind

The most interesting part wasn't the DCA mode itself. I added a lump sum comparison: what if you had all the money upfront instead?

In a pure bull market, lump sum wins every time. But most of us don't have a lump sum. We have a paycheck every two weeks. DCA isn't about maximizing returns — it's about removing the emotional tax of trying to time the market.

That's the real value. Not beating lump sum, but beating the alternative (which for most people is not investing at all because they're scared of buying at the top).

What I Learned Building It

Three things:

Date math is surprisingly annoying. Monthly intervals sound simple until you deal with uneven months and weekends.
Inflation visualization matters. Seeing nominal returns versus inflation-adjusted returns changes how you think about long-term projections.
People love sliders. I added a slider for monthly contribution amount and everyone who tried the tool spent more time playing with it than expected.

Try It Yourself

If you want to play with the calculator I built, it's live at financalcai.com. You can adjust the monthly amount, time horizon, and expected return rate to see how DCA plays out in different scenarios. No signup, no email required — just numbers.

Forza Horizon 6: What's Actually Different From FH5 (And What's Just Hype)

member_ce2645ea — Thu, 25 Jun 2026 12:53:14 +0000

I've put about 60 hours into Forza Horizon 6 since launch, and I've seen a lot of takes that miss the point. Here's what actually matters.

The Map: Germany vs. Mexico

FH5 gave us a beautiful but somewhat monotonous Mexico — lots of desert, some jungle, a volcano. FH6 moves to Germany, and the variety is night and day. Dense forests, autobahn sections, medieval towns with actual narrow streets that force different driving lines, and the Nürburgring Nordschleife integrated into the open world.

The big change isn't just scenery — it's road design. FH5 had long, sweeping corners that favored power builds. FH6 has technical sections that reward handling setups. If you're coming from FH5 with a garage full of 1500hp hypercars, you're going to struggle on the Black Forest roads. I wrote a detailed FH6 vs FH5 comparison covering the physics engine changes, car list differences (630 vs 530), and whether the upgrade is actually worth it.

The Festival Playlist System

FH6 revamped the weekly challenges. The Festival Playlist now has 8 different challenge types — PR Stunts, EventLab races, Championships, Playground Games, Photo Challenges, Treasure Hunts, Monthly Rivals, and Trials. Each awards different points toward the weekly car rewards.

The optimization meta has shifted. A 20-point car takes about 90 minutes of focused play. The 40-point car is 2-3 hours. The 160-point series reward is spread across 4 weeks at roughly 3-4 hours per week. If you're grinding efficiently, you want to prioritize Trial events (10 points each, fastest completion) and skip Playground Games unless you have a coordinated group. I put together a complete Festival Playlist optimization guide with point breakdowns and time estimates for every challenge type.

Tuning After the Tire Model Change

FH6 introduced a new tire model that changed how grip works at the limit. The old FH5 tunes are mostly obsolete — cars that handled perfectly in FH5 now understeer on corner entry or snap-oversteer on exit in FH6.

The new meta: S2 class is dominated by the Koenigsegg Jesko with specific downforce settings. S1 road racing is the Porsche 911 GT3 RS (2023). A class all-rounders lean on the Subaru WRX STI. For drifting, the Formula Drift 370Z is still king but requires a completely different alignment setup than FH5. I've been collecting and testing share codes for S2 through B class with tuner credits and spec sheets for each build.

Should You Buy It?

If you're into the physics and online racing: yes, the tire model alone makes it worth it. If you're a solo player who already owns FH5: wait for a sale, the content volume is similar. If FH5 didn't click for you: FH6 won't change your mind — it's an evolution, not a revolution.

What Actually Happens During an El Niño Winter — A Practical Guide for 2026

member_ce2645ea — Thu, 25 Jun 2026 12:53:13 +0000

El Niño winters get a lot of hype, but most people don't understand what they actually mean for real life. After the last major El Niño event (2023-24), I spent time researching the upcoming 2026-27 season and came away with practical insights that go beyond the weather channel soundbites.

The 30-Second Version

El Niño is a warming of Pacific Ocean surface water near the equator. It happens every 2-7 years and shifts global weather patterns for 6-12 months. The next significant one is forecast for late 2026, and different regions will feel it very differently.

What It Actually Means for Your Winter

If you ski or snowboard, this is the short version: the Sierras and southern Rockies tend to get dumped on during El Niño winters. The Pacific Northwest and Northeast? Not so much. I wrote a region-by-region breakdown of what skiers should expect from the 2026-27 El Niño season if you're planning trips.

If you're a homeowner, the bigger concern is flood and wind damage. Standard homeowners insurance doesn't cover flood damage — and most people don't realize this until it's too late. El Niño winters in California and the Gulf states mean saturated soil, atmospheric rivers, and a real risk of sewer backup flooding basements. I put together a detailed guide on El Niño home insurance gaps covering what standard policies miss and what riders you actually need.

Explaining This to a 10-Year-Old

My kid asked me "why does the ocean getting warmer make it rain more here?" and I realized El Niño is surprisingly hard to explain well. The bathtub analogy works: imagine filling a bathtub with warm water — the steam rises, moves across the room, and condenses on the cold mirror. The Pacific Ocean is the bathtub, and the "steam" is the jet stream shifting south and getting stronger, pushing storms into California and the southern US. If you need a simple El Niño explainer for kids or students, I wrote one with monitoring technology (buoys + satellites) and a comparison with La Niña.

Why This Matters More Than Before

El Niño events aren't getting more frequent, but their impacts are getting more expensive. More people living in coastal and wildfire-adjacent areas. Aging infrastructure. Insurance markets pulling out of high-risk states. Understanding what's coming isn't just interesting — it's practical risk management.

The good news: we can see these events coming 6-9 months in advance. NOAA's tropical Pacific buoy array gives real-time data, and seasonal forecast models have gotten remarkably good. If you're in an affected region, you have time to prepare. That's the whole point of understanding this stuff.

What I Learned Designing 50 Logos With AI (and When It Actually Works)

member_ce2645ea — Thu, 25 Jun 2026 12:52:16 +0000

I can't design a logo. I've tried. Every time I open Illustrator I spend an hour making something that looks like a first-grade art project.

So when AI image generation got good enough to produce usable graphics, I got curious: could I build something that generates actual logos, not just pretty pictures?

After making about 50 attempts, here's what I figured out.

The Problem With Most AI Logo Generators

Most AI image generators don't understand what a logo is. They generate beautiful illustrations that would never work as a logo — too much detail, wrong aspect ratio, text that looks correct from a distance but is gibberish up close.

A logo needs:

Simplicity — has to work at 16x16 pixels
Scalability — one version for a favicon, another for a billboard
Readability — if there's text, it has to actually be readable

Generative models are surprisingly bad at the third one. They'll produce something that looks like it says "TechCorp" until you zoom in and realize it's just shapes that vaguely resemble letters.

What Actually Works

The sweet spot is generative AI for the icon, plus programmatic rendering for the text and layout. Keep the AI part focused and constrained:

function generateLogoPrompt(business, style) {
  const styles = {
    minimal: 'flat vector, minimal, one or two shapes, clean lines, no text',
    geometric: 'symmetric geometric shape, abstract, sharp lines, solid colors',
  }
  return `Professional business logo for "${business}": ${styles[style]}. Solid background, simple composition, suitable for a website header.`
}

Feed that to an image model, get a clean icon back, then layer the text programmatically with proper fonts. The result looks much more like a real logo than anything the model produces on its own.

Style Selection Matters More Than You Think

I added 8 style presets after watching people generate 30 logos in the "default" style and hate all of them. Minimalist, geometric, vintage, tech — different businesses genuinely look better in different styles. Giving people a choice upfront saves a lot of iterations.

Try It

If you need a logo, the generator I built is at aielogo.com. Pick a style, type your business name, and see what comes out. No signup needed — it's just a tool.

I Tracked My Body Fat for 90 Days and Built a Calculator That Actually Makes Sense

member_ce2645ea — Thu, 25 Jun 2026 12:50:37 +0000

For three months, I weighed myself every morning and took body measurements every Sunday. I used a caliper, a tape measure, and a scale that probably lies to me about hydration levels.

The goal wasn't to get ripped. It was to understand whether any of these measurements actually mean something day to day.

The Problem With Most Health Calculators

Most body fat calculators fall into one of two camps:

Too simple — plug in height and weight, get a BMI number that tells you nothing about your actual composition.
Too complicated — requires measurements you need a degree to take correctly, plus an email signup and a paid subscription.

Neither is useful for someone who just wants to know "am I making progress?"

Building Something Practical

I put together a calculator that uses the Navy Method — it takes neck, waist, and hip measurements and estimates body fat percentage. The math has been around since the 80s and correlates reasonably well with DEXA scans for most people:

function navyBodyFat(gender, neck, waist, hip, height) {
  if (gender === 'male') {
    return 86.010 * Math.log10(waist - neck) -
           70.041 * Math.log10(height) + 36.76
  }
  return 163.205 * Math.log10(waist + hip - neck) -
         97.684 * Math.log10(height) - 78.387
}

The inputs are simple enough that anyone can take them with a tape measure. The output gives you a ballpark number that's consistent enough to track trends over time.

What 90 Days of Data Taught Me

Three things stood out:

Daily weight is useless; weekly trend is everything. My weight would swing 2-3 pounds daily due to water, food, and sleep. The weekly moving average was the only signal worth watching.
Body fat percentage changes slowly. Like, frustratingly slowly. In 90 days of consistent training, I moved maybe 2%. But that's real — if a calculator tells you you dropped 5% body fat in a month, it's broken.
Consistency beats precision. Taking measurements at the same time, under the same conditions, with the same method matters more than which formula you use.

Try It

The calculator I built is at bodycalctool.com. It includes BMI, body fat estimation, and a few other health metrics. No frills, no accounts — just input fields and numbers.

"I Built a Free AI Grammar Checker That Runs Entirely in the Browser"

member_ce2645ea — Thu, 25 Jun 2026 07:29:29 +0000

I Built a Free AI Grammar Checker That Runs Entirely in the Browser

A few months ago I got tired of copy-pasting my writing between five different tools — Grammarly for grammar, Hemingway for readability, some word counter for stats. So I built AI Grammar Checker — a single tool that does all of that in one shot, for free, with no signup.

What it does

You paste English text, hit check, and get back:

Sentence-by-sentence grammar corrections with explanations
Style polish — passive voice, weak adverbs, wordy phrases flagged
Flesch readability score so you know if your text is actually readable
Hemingway-style highlights — hard sentences, very hard sentences, adverb count
CEFR level (A1–C2) so non-native speakers know where they stand
Tone detection — formal, casual, neutral

All client-side except the AI check call. No server stores your text.

The stack is stupidly simple

HTML + vanilla JS + CSS
↓
DeepSeek API (OpenAI-compatible, $0.27/million tokens)
↓
Result rendered directly in the DOM

No React. No Next.js. No build step. Just app.js, style.css, and index.html. The "backend" is a tiny Cloudflare Worker that proxies the DeepSeek API call so the API key stays server-side.

Here's roughly how the grammar check works:

async function runGrammarCheck(text, intensity) {
  const systemPrompt = `You are a professional English editor.
Analyze the text sentence by sentence.
For each issue, return: original text, corrected text, explanation.
Also return: readability score, CEFR level, tone.`;

  const response = await fetch('/api/deepseek', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages: [
        { role: 'system', content: systemPrompt },
        { role: 'user', content: text }
      ],
      temperature: 0.3
    })
  });

  return response.json();
}

The intensity slider is the interesting bit — it adjusts the system prompt to be more or less aggressive about suggesting changes. At low intensity it only flags actual errors. At high intensity it rewrites for style too.

Why DeepSeek over OpenAI

Three reasons:

Cost. DeepSeek is roughly 1/10th the price of GPT-4o for comparable quality on grammar tasks. At the free tier usage levels, my API bill is literally under $2/month.
Quality on structured output. I tested both on the same 50-sample test set (emails, essays, blog posts). DeepSeek caught 91% of errors vs GPT-4o's 93%. The 2% gap isn't worth 10x the cost.
No content moderation false positives. This is the one nobody talks about. OpenAI's moderation API sometimes flags academic writing about medical or legal topics. DeepSeek just checks the grammar.

What I'd do differently

Offline mode. The Hemingway stats (passive voice, reading time, word count) are computed locally. The grammar check needs the API. I'd like to bundle a small on-device model via WebLLM eventually.
Better mobile UX. The tool works on mobile but the text area + results layout isn't great on narrow screens. Bootstrap or Tailwind would've helped but I wanted zero dependencies.
API key flow. Right now users bring their own DeepSeek key. New DeepSeek users get 5M free tokens, which covers a LOT of grammar checks. But the UX of pasting an API key is friction. Considering a free tier with a shared key + rate limiting.

Try it

→ grammaraicheck.com

Completely free, no signup, no email. If you write in English regularly — especially if you're a non-native speaker — I'd love feedback on what's missing.

Also have a comparison page if you're curious how it stacks up against Grammarly, ProWritingAid, and others: Best AI Grammar Checkers 2026.