DEV Community: Aryan

# I built a resume roaster in 2 hours without writing a single line of code

Aryan — Wed, 15 Apr 2026 18:41:18 +0000

I built a resume roaster in 2 hours without writing a single line of code

How vibe coding with MeDo changed the way I think about building products

I once sent out 47 job applications and heard back from 2.

Not because I wasn't qualified. Because my resume was quietly, invisibly terrible.

"Responsible for managing cross-functional teams." "Assisted in the development of key initiatives." "Worked collaboratively with stakeholders."

Translation: I did stuff. I think. Please hire me.

Every resume tool I tried gave me green checkmarks and told me I was doing great. I wasn't. I needed someone to tell me the truth.

So I built the tool that does exactly that — and I did it entirely through conversation, no code written by hand.

What I built

RoastMyResume — an AI-powered resume coach with two modes:

Roast Mode: line-by-line brutal critique of your resume. Vague bullets, passive voice, buzzword soup, missing metrics — all called out with a Roast Score out of 100.
Fix Mode: every weak line gets rewritten instantly. Strong verbs. Quantified impact. Recruiter-friendly language.
Job Match Mode: paste a job description, get your resume rewritten to match that specific role's language and ATS keywords.

Try it live: [your-app-url-here]

The tool: MeDo

I built this for the Build with MeDo Hackathon using MeDo — an AI app builder where you describe what you want in plain English and it generates, deploys, and hosts the full-stack app.

No IDE. No terminal. No Stack Overflow at 2am.

Just conversation.

The actual prompts I used

Here's exactly how I built it, turn by turn.

Turn 1 — Core scaffold

Build a full-stack web app called "RoastMyResume". Users paste their resume 
text into a text area. Two buttons: "Roast It" and "Fix It".

Roast It: AI critiques every weak line — vague bullets, buzzwords, passive 
voice, missing metrics. Give a Roast Score out of 100. Show each critique 
as a callout card with the original line and the burn.

Fix It: Rewrites every weak line with strong action verbs, quantified 
results, recruiter-friendly language. Show original vs improved side by side.

UI: clean, modern, dark header with orange accent. Deploy with one click.

MeDo generated the entire app. Frontend, backend, AI logic, deployment. In one shot.

Turn 2 — Deepen the roast engine

Make the critique more specific. Detect: passive voice, unquantified impact, 
buzzword density, generic responsibilities that could belong to anyone. 
Add severity weights — not all bad lines are equally bad.

This is where it got interesting. MeDo rewired the prompt engineering under the hood and added pattern classification logic I would have spent days building manually.

Turn 3 — Job Match Mode

Add a third mode: user pastes a job description. AI rewrites the resume 
to mirror that role's language and surface the most relevant experience. 
ATS-optimized output.

Turn 4 — Polish & virality

Add: animated Roast Score meter on results, shareable image card of the 
funniest roast lines (1200x630 for X/LinkedIn), PDF export, mobile 
responsive layout, counter showing "X resumes roasted today".

Turn 5 — Ship

One-click deploy. Public URL. Done.

Total time: ~2.5 hours.

What surprised me

Vibe coding is a real skill — and it's not about being lazy. The constraint of describing everything in plain English forces you to think like a product manager before you think like a developer. Fuzzy thinking produces fuzzy apps. Clear thinking produces clean apps.

Multi-turn context is the actual superpower. The app I shipped isn't the app from Turn 1. It's the app that emerged from five rounds of "yes, but also...". That's not how traditional coding works. It's closer to design thinking — iterative, responsive, human.

Honesty is a product differentiator. I checked every resume tool on the market while building this. They're all optimistic to the point of uselessness. There's a real gap for something that just tells the truth.

The math behind the Roast Score

The score isn't a fake "AI confidence" number. It's a transparent weighted penalty function:

$$S_{roast} = 100 - \frac{1}{n}\sum_{i=1}^{n} w_i \cdot p_i$$

Where:

$n$ = number of resume lines analysed
$w_i$ = severity weight of the issue type detected in line $i$
$p_i \in [0, 10]$ = penalty for that line

A score below 40 means your resume is on fire. Literally.

The biggest challenge: tone

The hardest problem wasn't the code. It was calibrating the roast voice.

Early versions were mean. Not "Gordon Ramsay calling out a burnt dish" mean — just demoralising. The kind of feedback that makes you close the tab. Getting MeDo to nail the voice of a sarcastic-but-constructive senior engineer took several prompt iterations. The key phrase that unlocked it:

"Roast the resume like you genuinely want this person to get hired. You're harsh because you care, not because you enjoy it."

That one sentence changed the entire output character.

What's next

Interview mode — practice answering questions about your newly fixed resume
Industry benchmarking — where does your score rank in your field's percentile?
Chrome extension — highlight any job posting, get an instant resume gap analysis
Before/after public gallery — the best roast transformations are genuinely funny

Try it

Live app: https://app-aysruew5kv7l.appmedo.com

Built with MeDo for the Build with MeDo Hackathon. If you want to try MeDo yourself, use this invite link for 300 free credits: medo.dev

Have a resume that needs roasting? Drop it in the comments. I won't be polite.

BuiltWithMeDo #buildinpublic #vibe-coding #career #ai #hackathon #webdev

"Building NecroOS: A Haunted Windows 95 Simulator with Kiro AI"

Aryan — Sat, 15 Nov 2025 20:41:29 +0000

# Building NecroOS: A Haunted Windows 95 Simulator with Kiro AI

What if your computer was haunted? Not just buggy—actually possessed. That 2 AM thought turned into NecroOS, a horror game disguised as a Windows 95 desktop simulator. And I built it using Kiro AI's spec-driven development workflow.

🎃 The Concept

NecroOS starts as a comforting Windows 95 desktop—teal wallpaper, chunky pixels, satisfying clicks. But gradually, subtly, things go wrong. Your cursor drifts. The calculator gives you 2+2=5. Files appear in folders you just emptied. The horror isn't in-your-face—it's the creeping dread of familiar technology betraying you.

Live Demo: necro-os.vercel.app

Source Code: github.com/AstaadDahiya/Necro-OS

🛠️ The Tech Stack

Vue 3 + Pinia for reactive state management
Google Gemini AI (2.5 Flash) for Cursed Clippy, Spirit Board, and Soul Scanner
Web Audio API for 4-layer dynamic audio mixing
98.css for authentic Windows 95 styling
Vite for blazing-fast development
Vercel for deployment

The numbers: 37,529 lines of code, 171 files, 11 functional apps, 4 difficulty modes, multiple endings.

🎯 The Kiro Difference: Spec-Driven Development

Here's where it gets interesting. I didn't just "vibe code" this project. I used Kiro AI's spec-driven workflow, which completely transformed how I build software.

The Traditional Approach (Vibe Coding)

Me: "Add some spooky audio effects"
Kiro: "What kind of effects? How should they trigger?"
Me: "Uh... whispers? When things get scary?"
Kiro: [Generates basic audio player]
Me: "Actually, I need multiple layers that blend dynamically..."
Kiro: [Refactors]
Me: "And it needs to scale with possession level..."
Kiro: [Refactors again]

Result: 3 iterations, inconsistent implementation, no clear architecture.

The Spec-Driven Approach

Instead, I created 4 comprehensive specs that became my project's blueprint:

necro-os - Base operating system
necro-os-advanced-haunting - Possession mechanics (22 tasks)
necro-os-visual-corruption - CRT effects and glitches
necro-os-progressive-corruption - Level-based haunting

Each spec had three documents:

1. requirements.md - The "What"

Using EARS format (Easy Approach to Requirements Syntax):

## Requirement 1: Possession Level System

**User Story**: As a player, I want the haunting to gradually intensify, 
so that I experience escalating horror over time.

**Acceptance Criteria**:
1. THE System SHALL track possession level from 0 to 100
2. WHEN possession reaches 30, THE System SHALL trigger cursor corruption
3. WHILE game runs, THE System SHALL increase possession by 1.5 points/min

2. design.md - The "How"

Technical architecture with formulas:

## Possession Level Formula

$$\Delta P = 1.5 \times m_d \times \frac{\Delta t}{60000}$$

Where:
- $\Delta P$ = possession increase
- $m_d$ = difficulty multiplier (Tourist: 0.5x, Nightmare: 3.0x)
- $\Delta t$ = time elapsed (ms)

## Audio Volume Scaling

$$V(P) = V_{\text{base}} \times (1 + 0.05 \times P)$$

3. tasks.md - The "When"

Actionable implementation checklist:

- [ ] 1. Set up Pinia store structure
- [ ] 2. Implement possession tracking with formula
  - Use setInterval for continuous updates
  - Apply difficulty multiplier
  - _Requirements: 1.1, 1.2, 1.3_
- [ ] 3. Add threshold watchers (30, 45, 70, 80, 100)

The Workflow in Action

Phase 1: Define requirements → "What should it do?"
Phase 2: Design architecture → "How should it work?"
Phase 3: Break into tasks → "What's the implementation order?"
Phase 4: Execute → "Implement task 2.1"

When I said "implement task 2.1", Kiro read all three docs and generated production-ready code with full context. No clarifying questions. No iterations.

💡 Strategic Prompt Engineering

The quality of AI-generated code is directly proportional to the context you provide. Here's what I learned:

❌ Vague Prompt

"Create an audio system"

✅ Precision Prompt

"Create a 4-layer audio haunting system using Web Audio API with independent 
gain nodes for ambient, effects, whispers, and tension. Scale volume using 
V = baseVolume × (1 + 0.05 × possessionLevel). Handle browser autoplay 
restrictions with lazy initialization. Integrate with Pinia advancedHaunting 
store for reactive updates."

The result: Kiro generated a complete, optimized audio system in one shot—Web Audio API architecture, gain nodes, volume formulas, autoplay handling, Pinia integration, error handling, and JSDoc documentation.

🎨 The Horror Mechanics

Possession System

Everything revolves around one number: possession level (0-100). It drives all horror effects:

30%: Cursor starts drifting
45%: Wallpaper flickers
70%: Whispers and phantom notifications
80%: Heartbeat tension, full chaos
100%: Possessed ending

4-Layer Audio System

Instead of random spooky sounds, I built a dynamic audio architecture:

class AudioHauntingService {
  layers = {
    ambient: { baseVolume: 0.3 },  // Background dread
    effects: { baseVolume: 0.5 },  // Phantom typing, HDD grinding
    whispers: { baseVolume: 0.2 }, // Barely audible voices
    tension: { baseVolume: 0.4 }   // Pre-jumpscare heartbeat
  }

  updateVolume(possessionLevel) {
    Object.entries(this.layers).forEach(([name, layer]) => {
      const multiplier = 1 + (0.05 * possessionLevel)
      const newVolume = layer.baseVolume * multiplier
      layer.gainNode.gain.setValueAtTime(newVolume, this.audioContext.currentTime)
    })
  }
}

Volume scales with possession level, creating audio that responds to gameplay.

Exorcism Mechanics

Players aren't helpless:

Text Exorcism: Type "begone spirit" (-15 possession)
File Exorcism: Delete cursed files (-8 possession)
Puzzle Exorcism: Complete symbol sequences in 30s (-20 possession)

Each has a 2-minute cooldown, creating strategic gameplay.

AI Integration with Gemini

Three apps use Google Gemini AI:

Cursed Clippy: Sarcastic AI assistant with command execution

systemPrompt: `You are Cursed Clippy, a sarcastic AI haunting a Windows 95 
desktop. Make references to being trapped. Use 90s internet culture. 
Execute commands via [COMMAND:action:target] syntax.`

Spirit Board: Ouija board with AI-generated responses

prompt: `You are a spirit communicating through a Ouija board. 
Respond in max 30 characters. Use only letters, numbers, spaces.`

Soul Scanner: Webcam facial expression analysis with Gemini Vision API

prompt: `Analyze this person's expression in one cryptic sentence (max 15 words). 
If happy, threaten them. If scared, mock them. If neutral, make eerie observations.`

📊 The Results

Time Comparison:

Planning with specs: 2 hours
Implementation: 6 hours (22 tasks)
Refactoring: 30 minutes
Total: 8.5 hours

Without specs: Estimated 20+ hours with multiple rewrites

Quality Improvements:

✅ Got it right the first time (minimal refactoring)
✅ Consistent architecture across all features
✅ Built-in documentation
✅ Clear definition of "done"
✅ Easy to resume after breaks

🎓 Key Lessons

1. Spec-Driven > Vibe Coding for Complex Projects

Specs aren't slower—they're front-loaded thinking. Spend 2 hours planning to save 12 hours refactoring.

2. Specificity Beats Brevity in Prompts

Bad: "Make it faster"
Good: "Batch DOM updates using requestAnimationFrame to maintain 60 FPS"

3. Context Persistence is Everything

Specs gave Kiro a complete mental model. Each conversation built on the last. No context loss between sessions.

4. Accessibility in Horror is Possible

I added photosensitivity warnings, reduced motion mode, and keyboard navigation without losing the scary parts.

5. Audio is 50% of Horror

Investing in the Web Audio API multi-layer system paid huge dividends. Simple <audio> tags wouldn't have cut it.

🚀 What's Next

I'm planning:

Multiplayer haunting where possession spreads between users
Procedural jumpscare generation using AI
VR support for truly immersive terror
More endings based on player choices

💭 Final Thoughts

NecroOS started as a weird 2 AM idea and turned into the most complex project I've built. But the real story isn't the horror game—it's discovering that spec-driven development with AI is a game-changer.

Kiro didn't build NecroOS. I architected it through strategic prompts and specs. Kiro implemented my vision.

That's the difference between "AI wrote my code" and "I used AI as a force multiplier for my ideas."

The haunting is just beginning. 👻

Try it: necro-os.vercel.app

Source: github.com/AstaadDahiya/Necro-OS

Built with: Vue 3, Gemini AI, Kiro, and way too much coffee ☕

kiro #ai #webdev #gamedev #vue #horror