Background

With over 15 years of experience as an interviewee and more than 5 years conducting interviews myself, I have encountered a wide range of recruitment scenarios. This article outlines the principles I follow when engaging in the hiring process, ensuring a high success rate and satisfaction for both the company and the candidate.

Summary

1. Look for a Glint in the Eye – Identify passion and enthusiasm in how candidates discuss their work.
2. Be Wary of What You Interview For – Focus on relevant skills rather than outdated technical trivia.
3. Never Ask for Easy-to-Find Technical Knowledge – Assess problem-solving, not memorization.
4. Speak the Language & Culture of Your Team – Ensure communication and team fit.
5. Ensure a Stable Technical Background – A lack of a technical degree can be a red flag.
6. Embrace AI – Don’t Fear It – Ask about creative AI usage instead of discouraging it.
7. Turn the Interview into a Learning Opportunity – Use interviews to gain insights into your own challenges.
8. Study Psychology – Being the Interviewer Doesn’t Make You a People Expert – Improve your ability to evaluate candidates.

Full Article

Look for a Glint in the Eye

A great programmer isn’t just someone who can write code—they love writing code. Passion, curiosity, and enthusiasm are key traits of high-quality developers. When discussing technical challenges, do their eyes light up? Do they seem genuinely excited about problem-solving?

One of my favorite ways to assess this is by asking:

“What’s a feature you’re most proud of developing?”

This question serves multiple purposes:

• It reveals what kind of problems excite the candidate.
• It shows how deeply they understand their own work.
• It gives insight into their level of ownership and engagement.

Watch How They Speak About It

It’s not just about what they say—it’s about how they say it. Pay attention to their tone, energy, and enthusiasm:

• Do they light up when describing the problem and solution?
• Can they clearly articulate why they’re proud of it?
• Do they get into interesting technical details without you having to push?

When a candidate is genuinely passionate, you can feel it. They might instinctively sketch out a solution on paper, explain trade-offs without being asked, or express excitement about what they learned during the process.

On the other hand, if they give a flat, uninspired response or struggle to describe the impact of their work, that’s a red flag. Great developers take pride in their creations and enjoy discussing them.

The Best Developers Love the Craft

Hiring for passion doesn’t mean looking for flashy projects—it means finding those who enjoy problem-solving and continuously seek to improve. A developer who shows a genuine glint in their eye when talking about their work is far more valuable than someone with a perfect resume but no real excitement for the craft.

Be Wary of What You Interview For

One of the biggest mistakes companies make when hiring programmers is testing for the wrong skills. Too often, interviewers ask theoretical questions that have little relevance to the candidate’s actual day-to-day work.

For example, let’s say you’re hiring a Senior Unreal Engine 5 Developer with 5+ years of experience—a highly specialized role requiring expertise in game engine optimization, rendering, and physics simulations. But instead of assessing their ability to work with UE5, you ask them about vanilla C++ standard libraries, like:

"Can you explain how std::map is implemented internally?"

While this might seem like a fair question for a general C++ role, it has little to no relevance for an Unreal Engine expert. UE5 developers rarely need to manually optimize std::map, as Unreal’s API provides its own efficient data structures like TMap.

Stop Testing for Outdated or Unused Knowledge

Great programmers don’t waste brain space memorizing things they can easily look up in seconds. Expecting them to store outdated knowledge or recall obscure syntax does not reflect their ability to perform on the job.

Instead of testing rote memorization, evaluate them on:

• Their ability to solve real-world problems in their tech stack.
• How they think through a challenge and break it down.
• How they use available tools and documentation—because real work involves research.

Ask Candidates to Work in a Realistic Environment

A better approach is to give them a practical take-home task or a coding exercise in a familiar setting. Instead of algorithm puzzles or low-level trivia, try:

• For Unreal Engine devs: Ask them to optimize a sample UE5 scene for performance.
• For web developers: Give them an actual feature request in React or Node.js.
• For mobile developers: Ask them to debug or extend an existing Swift or Kotlin app.

By mimicking real-world tasks, you get a true sense of how they work, collaborate, and adapt—without making them jump through unnecessary hoops.

Conclusion: Interview for What Matters

If you test for the wrong skills, you’ll end up hiring the wrong people. Instead of evaluating knowledge that can be Googled, focus on how they think, solve problems, and perform in a real work environment. The best developers aren’t walking encyclopedias—they are problem solvers.

Never Ask for Easy-to-Find Technical Knowledge

Programming is not about memorization—it’s about problem-solving. Yet, many interviews still rely on trivia-based questions that test how much a candidate has stored in their brain rather than how well they can apply their skills.

The reality is that a programmer’s memory is limited, and software development grows exponentially. Expecting developers to recall syntax, obscure functions, or theoretical time complexities off the top of their heads is outdated and counterproductive.

The Knowledge Explosion in Programming

Consider how fast the industry evolves:

• New frameworks, languages, and tools emerge every year.
• Best practices change as technologies improve.
• Libraries and APIs get updated—sometimes drastically.

No developer, no matter how senior, can keep all this information in their head. In fact, the best programmers don’t try to—they focus on how to quickly find and apply the right solutions.

Would You Expect a Doctor to Memorize Every Medical Study?

A good analogy: You wouldn’t expect a doctor to recall the details of every medical study ever published—you expect them to know where to look and how to apply the latest research to treat a patient.

Similarly, great developers:

• Know how to search for answers efficiently (e.g., documentation, Stack Overflow).
• Understand core concepts and patterns, rather than memorizing syntax.
• Can break down complex problems into manageable solutions.

Ditch the Trivia, Focus on Real-World Application

Instead of asking something like:

“What is the difference between BFS and DFS?”

Ask:

“Here’s a tree structure. How would you traverse it in a way that prioritizes depth first?”

This way, you’re not testing memorization—you’re testing their ability to apply knowledge in a real-world scenario.

Programmers Who Memorize Everything Are Probably Not the Best

Some candidates might ace trivia-heavy interviews, but that doesn’t mean they can write scalable, maintainable code. The best developers are those who:

• Know how to learn new things quickly.
• Adapt to changes in the industry.
• Understand how to use documentation and existing tools effectively.

Conclusion: Hire Problem Solvers, Not Encyclopedias

If your interview process prioritizes memorization over real-world problem-solving, you risk hiring the wrong kind of programmer—someone who knows a lot of facts but struggles to apply them effectively.

The best programmers don’t try to store everything in their heads—they know how to think, adapt, and use resources efficiently.

Speak the Language & Culture of Your Team

Hiring the best programmers isn’t just about technical skills—it’s also about team fit. A developer might be a coding genius, but if they don’t communicate well with the team, don’t align with the work culture, or cause persistent conflicts, they can become more of a liability than an asset.

One of the easiest ways to gauge team fit early is by using the same language and communication style you use in your team during the interview.

Use the Same Language as Your Team

This doesn’t just mean speaking English, Spanish, or any other national language. It means:

• Using the same technical jargon and shorthand your team naturally uses.
• Structuring conversations the way they would happen in a real work setting.
• Seeing if the candidate naturally aligns with how your team communicates and collaborates.

For example, if your team has a casual, collaborative culture, an interview filled with rigid corporate-speak won’t give you a clear picture of whether the candidate fits in. Instead, keep it natural—speak to them as if they’re already part of the team.

This helps answer crucial questions:

• Does the conversation flow naturally, or does it feel forced?
• Do they understand and engage with your team’s style of discussion?
• Would you feel comfortable discussing complex ideas with them on a daily basis?

A Personal Experience: When a Candidate Talks Only About Themselves

I once interviewed an Engine Programmer from a top game development studio. On paper, he was an outstanding candidate—his C++ knowledge was perfect, and his resume was packed with impressive projects. But the interview quickly became exhausting.

Why?

Because instead of talking about what he could contribute to the team, he only focused on what the company could offer him. Every question led back to:

• How much he’d get paid.
• What perks and benefits he’d receive.
• How the company could help his career grow.

I found myself drained by the conversation, and honestly, I left the interview earlier than planned. It was clear that, despite his technical brilliance, he wouldn’t be a good cultural fit.

The best hires aren’t just those with impressive resumes—they’re the ones who show a genuine interest in contributing to the team, improving the company, and collaborating with others.

Persistent Conflicts Can Kill Agile Teams

In an agile environment, smooth communication is crucial. Team members constantly:

• Discuss requirements.
• Review each other’s code.
• Collaborate on solutions.
• Provide constructive feedback.

If a candidate’s communication style clashes with the team—whether they’re too aggressive, too passive, or just don’t align—it can create persistent conflicts that drag everyone down.

The worst-case scenario?

• A toxic work environment where every discussion turns into an argument.
• A team that avoids collaboration because communication is frustrating.
• An agile process that breaks down because of poor interpersonal dynamics.

This is why hiring isn’t just about coding skills—it’s about hiring someone you can work with every day without unnecessary friction.

Hire for Team Compatibility, Not Just Individual Brilliance

Some developers may be brilliant coders but difficult to work with. Others might be slightly less experienced but communicate well and enhance team synergy. In an agile environment, the latter is often the better choice.

A good rule of thumb:

If you wouldn’t enjoy discussing a complex problem with them over a coffee or a Zoom call, they’re probably not the right fit.

Conclusion: The Right Fit is More Than Just Skills

A great developer isn’t just someone who writes excellent code—they’re someone who fits naturally into your team and contributes to a smooth, productive work environment.

By speaking the same language as your team during the interview and looking for a give-and-take mindset, you can spot potential friction early and ensure you hire someone who truly fits.

Ensure a Stable Technical Background

Technology evolves at an incredible pace, and frameworks, libraries, and programming languages change constantly. However, fundamental programming concepts remain the same—and a strong developer should have a solid technical foundation to adapt and grow over time.

The Importance of a Strong Foundation

A developer who understands data structures, algorithms, memory management, and system architecture will always outperform one who has only learned frameworks or libraries without grasping the underlying principles.

This is why I personally see a lack of any technical degree as a red flag.

Why a Technical Degree Matters

I’m not saying that great programmers can’t be self-taught. Some of the best developers have learned on their own. However, when hiring, a degree provides a baseline understanding of their technical education. Without it, I have no way of knowing what their fundamental knowledge looks like.

A formal education in computer science, software engineering, or a related field ensures that a developer has been exposed to:

• Theoretical and practical knowledge of algorithms and data structures
• Low-level concepts like memory management, concurrency, and computational complexity
• Software design principles and best practices

Without this foundation, a candidate might struggle with:

• Scaling applications efficiently.
• Debugging low-level performance issues.
• Understanding why certain architectural decisions are made.

Self-Taught vs. Formally Educated: Why It Matters in Hiring

Of course, some self-taught programmers are exceptional, but they tend to be the exception rather than the rule. The challenge in hiring them is that it’s harder to assess their foundations.

If a candidate doesn’t have a degree, I need to dig deeper in the interview:

• Where did they learn computer science fundamentals?
• Can they explain the reasoning behind their coding decisions?
• Do they struggle when stepping outside their usual tech stack?

If they’ve built solid fundamentals through practical experience, I’ll still consider them—but if they lack both a degree and evidence of deep technical understanding, that’s a major red flag.

A Developer Who Only Knows a Framework is Not a Strong Developer

A developer who only knows React, Laravel, or Unity without understanding how things work under the hood is limited in how much they can contribute in the long run.

If you hire someone who only knows how to copy-paste code from Stack Overflow without fully understanding it, you risk ending up with:

• Unmaintainable code
• Performance bottlenecks
• Developers who struggle outside of their comfort zone

This is why I focus on technical foundations first, frameworks second.

Conclusion: A Strong Foundation is Non-Negotiable

A great developer isn’t just someone who knows a particular framework—they have a deep understanding of software engineering principles that allows them to adapt to new challenges.

A technical degree serves as a strong indicator of this foundation, and while there are exceptions, a candidate without one must demonstrate an equivalent level of knowledge to be considered.

When hiring, I prioritize those who have a clear, stable technical background, ensuring they can contribute to the team not just today, but for years to come.

Embrace AI – Don’t Fear It

Too many companies still treat AI as a threat rather than a tool. There’s a common misconception that real programmers don’t use AI, but that mindset is outdated and counterproductive. Instead of punishing candidates for using AI-assisted tools, interviewers should be asking how they leverage them effectively.

AI Is a Productivity Booster, Not a Shortcut

Modern developers don’t spend hours debugging a misplaced semicolon or memorizing syntax—they use AI tools like ChatGPT, Copilot, and Tabnine to streamline their work. The best engineers understand:

• AI can generate boilerplate code, but human creativity is irreplaceable.
• AI helps with efficiency, but problem-solving skills still define great developers.
• Knowing how to use AI smartly is now a core skill, not an optional extra.

Instead of asking, "Do you use AI?" (which is becoming a meaningless question), ask:

“How do you incorporate AI tools into your development workflow?”

This turns the discussion into something valuable and gives insight into how they:

• Use AI creatively rather than blindly copy-pasting.
• Understand its limitations and when not to rely on it.
• Optimize their workflow and increase efficiency.

A Smart AI User Is a Smarter Developer

A great follow-up question is:

"Can you give me an example of a situation where AI helped you solve a problem?"

This reveals a lot about how practically and strategically the candidate uses AI. Are they:

• Using it for code completion and automation?
• Generating test cases or documentation?
• Debugging and finding alternative solutions?

The Interviewer Can Learn Too

The best part? You might learn something new from their approach. AI is evolving rapidly, and every developer has different tricks and techniques. A strong candidate might introduce you to a more efficient way of working with AI that you hadn’t considered before.

Rather than seeing AI as a threat to programmers, treat it as a tool for innovation—and look for candidates who know how to use it wisely rather than fear it.

Conclusion: AI-Savvy Developers Are the Future

The future of software development isn’t about memorizing code—it’s about knowing how to solve problems efficiently. The best developers aren’t avoiding AI—they’re mastering it.

By shifting interview questions from “Do you use AI?” to “How do you use AI?”, you’ll discover candidates who are not only adaptable but actively pushing the boundaries of what’s possible.

Turn the Interview into a Learning Opportunity

Too many interviews are one-sided interrogations, where the interviewer fires off questions without getting any real value in return. But think about it—you have a specialist in front of you, for free, for an hour. Why waste this opportunity?

Instead of sticking to generic interview questions, ask something that could actually help your current work.

Use the Interview to Solve Real Problems

A strong candidate has years of experience, sometimes in areas where your team is currently struggling. Instead of just testing their knowledge, leverage it.

Ask something like:

“We’re currently facing [specific challenge] in our project. How would you approach solving it?”

Examples:

• Hiring a DevOps Engineer? Ask how they would optimize your current CI/CD pipeline.
• Interviewing a Game Developer? Get their take on improving rendering performance.
• Hiring a Backend Engineer? See how they’d design a scalable API for a real feature your team is building.

This approach benefits you in multiple ways:

• You get fresh insights from an expert.
• You see how they approach real-world challenges.
• They feel more engaged in the interview.

It’s a Two-Way Value Exchange

A great developer will enjoy this type of conversation. Instead of answering trivia questions, they get to engage with real problems—which is what they do best.

And the best part? Even if you don’t hire them, you might walk away with valuable insights that help your current team.

Candidates Appreciate a Thoughtful Interview

Asking questions tied to real-world work also shows you respect their time and expertise. It makes the interview feel less like a test and more like a professional discussion between peers.

A developer who feels engaged and valued during an interview is more likely to accept an offer, because they’ll see your company as one that fosters intelligent discussions and values its engineers.

Conclusion: Every Interview is an Opportunity to Learn

Stop treating interviews as one-sided exams. Instead, turn them into valuable technical discussions that help both you and the candidate.

If you have a specialist in front of you, use that hour wisely—not just to assess them, but to gain insights that can improve your projects today.

Study Psychology – Being the Interviewer Doesn’t Make You a People Expert

Just because you’re the one conducting the interview doesn’t mean you automatically understand people. Too many hiring managers assume that years of experience alone make them good at evaluating personalities, motivations, and culture fit. The reality? Without studying psychology, you’re making guesses—and that can lead to bad hires.

Hiring Isn’t Just a Technical Process – It’s About People

You might be an expert in programming, system architecture, or DevOps—but hiring isn’t just about tech skills. It’s about human behavior.

A few key psychological insights can help you:

• Recognize when a candidate is masking weaknesses with confidence.
• Identify truly passionate developers versus those who “say the right things.”
• Detect red flags in personality that could disrupt team dynamics.
• Understand biases in your own judgment that might cause you to reject great candidates.

Without studying psychology, you risk hiring:

• Smooth talkers over skilled problem solvers.
• People who "fit the mold" rather than those who bring real value.
• Candidates who interview well but struggle in real work environments.

Push Your Own Development to Find (and Attract) Better Candidates

Being on the hiring side means you’re representing the company. If you lack confidence, struggle with interpersonal skills, or come across as unsure in the interview, great candidates will sense it—and they may lose interest.

A confident, well-prepared interviewer doesn’t just assess candidates—they also make the candidate want to work for the company.

How to Improve Your People-Reading Skills

Here are a few simple but powerful ways to develop psychological awareness:

• Learn about cognitive biases – Avoid snap judgments and unconscious favoritism.
• Study behavioral psychology – Understand how and why people respond the way they do.
• Practice active listening – The best interviewers make candidates feel heard, not interrogated.
• Improve your own confidence – The way you present yourself in an interview directly affects how the company is perceived.

Better Self-Development = Better Hiring Decisions

The more you work on understanding people, the better you’ll be at identifying strong candidates and making them excited to join your team.

A great programmer isn’t just about technical skills—it’s about how they work, communicate, and fit into the team. And the better you get at reading people, the better hires you’ll make.

Conclusion: The Best Hiring Managers Invest in Their Own Growth

Hiring is a two-way street. You’re not just evaluating candidates—they’re evaluating you and your company. By improving your understanding of psychology, you become better at spotting the right talent and more attractive as a representative of your team.

Simply being on the hiring side doesn’t make you a people expert—but investing in self-development does.

Conclusions

Throughout my years of interviewing and being interviewed, I’ve learned that hiring is as much about understanding people as it is about assessing skills. I’ve walked away from interviews where technically perfect candidates lacked enthusiasm, and I’ve seen passionate problem-solvers thrive despite gaps in their knowledge.

A structured, thoughtful hiring process ensures you’re not just hiring great coders, but also great team members. By following these eight rules, you can build a strong, adaptable, and motivated development team—one that contributes meaningfully to your company’s success while fostering a collaborative and enjoyable work environment.