DEV Community: Luca

I built a simulator for the hiring systems that filter candidates before humans ever see them

Luca — Tue, 14 Apr 2026 17:38:47 +0000

Most hiring pipelines today start with automated systems.

Not interviews.

Systems.

Things like:

HireVue game-based assessments
one-way video interviews
asynchronous screening platforms

From a dev perspective, these are not “interviews”.

They’re black-box evaluation systems with:

constrained inputs (your responses)
hidden scoring logic
strict timing constraints
no feedback loop

And yet, candidates are expected to perform optimally on first exposure.

The actual problem

This is not primarily a “skill” issue.

It’s a system familiarity problem.

If you think about it like engineering:

You’re being evaluated by a system you’ve never interacted with,
with unknown rules,
under time pressure,
with no debugging.

That’s a terrible setup.

Why candidates fail (technical framing)

From what I’ve seen, failure usually comes from:

1. Unknown interface

Users don’t understand:

what inputs are expected
how interactions map to outcomes

Equivalent to using an API without docs.

2. Timing constraints

These systems are heavily time-bound.

You’re effectively dealing with:

real-time decision loops
limited processing time per action

Think competitive programming, but without knowing the problem format.

3. Hidden evaluation function

The scoring logic is opaque.

Candidates don’t know:

what signals are being captured
how they’re weighted

So they optimize blindly.

4. No iteration

You don’t get:

retries
logs
feedback

It’s a single execution with production consequences.

What I built

I built Candidate Falcon as a way to simulate these systems.

Not to “teach interviews”, but to replicate:

interaction patterns
timing constraints
cognitive load
format structure

So users can build a mental model before the real run.

Design approach

The goal wasn’t content.

It was system replication.

For each assessment type, I focused on:

matching interaction mechanics
reproducing timing behavior
simulating decision pressure
removing ambiguity around flow

Basically:

If the real system is a black box, this is a local sandbox.

Example: game-based assessments

HireVue-style games are not “games” in the traditional sense.

They’re:

cognitive tasks
signal extraction pipelines
behavior measurement tools

So instead of strategies like “do X to win”, the useful layer is:

understanding task structure
recognizing patterns early
allocating attention correctly
avoiding time-based errors

Example: one-way video interviews

These are closer to:

async request/response systems
with strict timeouts
and no back-and-forth

The difficulty is not answering questions.

It’s handling:

delayed prompts
recording constraints
timeboxing your response
maintaining coherence under pressure

Why this matters

If you’re a dev, this pattern should feel familiar:

You don’t fail systems because you lack ability.

You fail because:

you don’t understand constraints
you misread the interface
you optimize for the wrong signals

Once the system is understood, performance improves quickly.

What I’m testing

Right now I’m trying to validate a simple idea:

Is familiarity with the system enough to significantly improve outcomes?

Early signals suggest yes.

But I’d like more input, especially from people who’ve gone through:

HireVue
Pymetrics
Codility / HackerRank-style screens (slightly different, but similar constraints)

Open questions

How would you model these systems more accurately?
What signals do you think they actually optimize for?
Where would you draw the line between “prep” and “overfitting”?

If you want to see what I mean:
https://candidatefalcon.com

I Built an AI Tool to Practice Interviews Like the Real Ones (Not Generic Q&A)

Luca — Thu, 15 Jan 2026 15:29:53 +0000

A while ago, I was preparing for job interviews and realized something frustrating.

Most interview prep tools either:

give you generic questions, or
focus on theory, not real interview pressure.

But interviews today (especially video interviews) are very specific:

different roles
different seniority levels
structured answers
time pressure
AI screening on the other side

So I built Complete Interview Prep.

What Complete Interview Prep Actually Does

Instead of random questions, the platform lets you:

Practice realistic interview simulations
Choose job role, seniority, and interview type
Answer via video or text
Get AI feedback on structure, clarity, relevance, and confidence

It’s designed to feel like the interview you’ll actually face, not a quiz.

Why I Built It

I kept seeing strong candidates fail interviews not because they lacked skills, but because they:

didn’t structure answers well
froze on camera
underestimated how automated screening works

Interviewing is a skill. And like any skill, it improves with deliberate practice.

Who It’s For

Developers preparing for technical or behavioral interviews
Juniors entering the job market
Mid / senior professionals changing roles
Anyone dealing with video interviews or AI-screened hiring

What Makes It Different

No canned answers to memorize
No fake “pass/fail” scoring
Feedback focuses on how to improve, not just what you did wrong

You practice, reflect, iterate — just like real preparation.

Try It (Free Plan Available)

If you’re interviewing soon, or just want to get better before it matters, you can try it here:

👉 https://completeinterviewprep.com

I’m actively improving it, so feedback from other devs is more than welcome.

Happy interviewing 🚀

How I Built Game Assessment Prep in 3 Weeks by Focusing on a Tiny Niche (and Vibecoding the Rest)

Luca — Fri, 05 Dec 2025 22:19:58 +0000

Every founder talks about “focus,” but very few actually commit to it. When I built GameAssessmentPrep.com, a platform that helps job candidates prepare for HireVue’s cognitive and game-based assessments, I didn’t have the luxury of time, resources, or a team. What I did have was a clear niche and a very aggressive deadline.

It ended up taking just 3 weeks to go from idea to shipped product.

This is the story of how extreme focus + vibecoding (AI-assisted coding guided by intuition and fast iteration) made it possible — and the lessons I’d share with anyone building solo.

1. Picking a Niche So Specific It Felt Uncomfortable

When I tell people I built a training platform for HireVue game-based assessments, the answer is always the same:

“Wait... there’s a niche for that?”

Yes — and it’s massive, once you zoom in.

HireVue assessments are used by Fortune 500 companies, banks, and global employers to screen candidates. Most candidates walk in blind, stressed, and completely unprepared. That’s a real, painful, repeatable problem.

But here’s the catch:
If I had tried to build “a general job-prep platform,” I would have shipped in 3 years.
By narrowing the scope to 11 specific game types, I could design:

focused simulations
focused UX
focused onboarding
focused marketing copy
focused SEO

Everything aligned because everything was intentionally small.

Lesson: If your niche doesn’t feel uncomfortably narrow, it’s probably too broad.

2. Vibecoding: Shipping Before I Know the Perfect Way

I’m a solo founder. I don’t have time to reinvent the wheel or design systems like a 50-engineer team. So I defaulted to what I call vibecoding:

Code guided by intuition, rapid feedback loops, and AI-assisted exploration — instead of over-planning.

My vibecoding workflow looked like this:

Sketch the screen in my head.
Describe it to AI and let it scaffold the boilerplate.
Modify until it “feels right.”
Ship. Even if imperfect.
Improve once real users touch it.

This reduced friction at every step. I didn’t stop to think, “Should this be architected with X pattern?” I thought:

Does it work?
Is it fast to implement?
Will users understand it?

That’s it.

Lesson: Perfection is a trap. Momentum is a multiplier.

3. Building Only What Mattered (and Cutting Everything Else)

Because the deadline was tight, every feature had to justify its existence.
If it didn’t directly help a candidate perform better in a HireVue-style game, it was deleted.

This meant:

No unnecessary dashboards
No complex gamification systems
No social features, no messaging, no AI tutors (at first)
No admin interface for the first week

Instead, I focused on:

🔹 A clean UI that mirrors real assessment conditions

🔹 Precise replicas of each HireVue game mechanic

🔹 Analytics users actually care about (accuracy, speed, error patterns)

🔹 UX that lowers anxiety instead of increasing it

Those core pillars generated 90 percent of the platform’s value.

Lesson: If a feature doesn’t create value today, it’s a distraction.

4. Iterating With Real Anxiety (Because Users Don’t Care About Your Code)

The most surprising insight came from user behavior:

Candidates using GAP were stressed.
Their heart rate was literally going up while playing these training games.

That told me something important:

The UX shouldn’t just teach the mechanics.
It should help users stay calm under cognitive pressure.

So I added:

clean spacing
predictable flows
gentle animations
reassuring microcopy
immediate feedback loops

This turned GAP from “a set of minigames” into an emotional training platform.

Lesson: You're not building features — you're reducing user stress.

5. The Technical Stack (Kept Simple on Purpose)

Frontend: Next.js
Payments: Stripe
Authentication & backend logic: Supabase
Deploy: Vercel

I didn’t try to be clever. I tried to be fast.

Every time I felt tempted to add a complicated system, I asked myself:

“Will this meaningfully improve the user’s chance of passing a HireVue assessment?”

If the answer wasn’t a strong yes, it was cut.

6. Marketing the Niche (The Secret Weapon)

The beauty of a specific niche is that marketing becomes laser targeted.

SEO becomes straightforward because you're not fighting giants.
Reddit posts convert.
LinkedIn posts convert.
Even YouTube descriptions convert.

Instead of trying to “educate the whole world,” I built content around:

“How to pass HireVue’s Flashback game”
“Why candidates fail Spatial Pathfinder”
“How to prepare for cognitive game-based assessments”

The niche did most of the heavy lifting.

Lesson: Specificity is free distribution.

7. What I Learned (That I Wish I Knew Earlier)

1. A tiny niche can be a huge business.

2. Vibecoding with AI dramatically compresses time to market.

3. Users don’t care how elegant your codebase is.

4. You can skip 80 percent of the work by building only what users truly need.

5. Three weeks is enough time to build something people will pay for — if you stay radically focused.

Final Thoughts

GAP didn’t succeed because I’m a genius or because I had the perfect plan.

It succeeded because:

I chose a niche so specific that competitors ignored it
I shipped fast before I could overthink
I vibecoded my way through uncertainty
I focused obsessively on solving one clear problem

If you're building something solo in 2025, the formula hasn’t changed:

Focus small. Ship fast. Let users guide you. And trust your intuition more than your architecture diagrams.