Key Takeaways
Hire rare talent because software quality can create winner-take-most products
Talent changes the product. Spolsky argues that software is unusual: once made, it can be copied at almost no extra cost, so better design can add far more value than it adds expense. In a product company, a small team of exceptional developers may build something competitors cannot match by simply adding more staff. More programmers can also mean more coordination, not more output. Brooks’ Law describes this coordination trap: adding people to a late software project can make it later.
The gap is not just speed. Data from Yale programming assignments showed large differences in time spent, including among students whose code scored in the top quarter. Spolsky reads this as evidence that developers vary dramatically in productivity, and argues that the best also produce creative touches average teams may miss. His case applies most strongly to products where quality drives adoption, not routine internal software.
What's striking is the connection between software's low copying cost and the value of design: a small improvement can reach every customer without a matching rise in production expense. That makes talent a strategic investment, not merely a labor cost. The Yale assignments offer a useful comparison because students tackled similar tasks, but they are not a controlled measure of workplace performance, and time spent was self-reported. The broader lesson is persuasive, while the exact productivity multiples should be treated as suggestive rather than universal.
Go find top developers where they gather instead of waiting for applications
Hiring is an obstacle course. A candidate may never hear of a company, notice an opening, live nearby, pass screening, or accept an offer. In Spolsky's illustration, if each of ten hurdles eliminates half the applicants, 1,024 people must start for one to clear them all. Removing a single hurdle can double the number who make it through the rest.
The best are rarely browsing. Strong developers often get recruited through professors, colleagues, or interesting projects, so a general job board tends to produce many applicants but few standouts. The book recommends reaching candidates through technical conferences and relevant communities, and building a pipeline through paid internships. At Fog Creek, interns worked on production software, got mentorship, and experienced the company before deciding whether to join full time.
The obstacle-course model shifts recruiting from a search problem to a system-design problem. It also explains why polishing only the resume filter cannot compensate for a location, reputation, or interview process that deters strong applicants. Targeted communities can improve relevance, but they can also reproduce a team's existing social network and narrow its perspective. A healthy strategy therefore combines focused outreach with deliberate efforts to reach people outside familiar circles.
Give developers quiet rooms, capable tools, and visible respect
The workplace sells the job. Candidates judge the everyday environment during interviews: noisy shared desks, worn-out rooms, and poor equipment suggest how the company values its developers. Spolsky favors private offices because focused programming is easily interrupted and because private space carries status. He also argues for fast computers, large monitors, technical books, and comfortable chairs. His Aeron-chair comparison makes the point that a costly item can be inexpensive over its useful life.
Small frictions accumulate. The office should be bright, clean, and pleasant, not decorated with stale slogans about teamwork. Developers notice whether they are treated as skilled contributors or as interchangeable typists. A company cannot always move or renovate immediately, but it can inspect the candidate's experience honestly and address the obstacles it controls.
The case for quiet space connects to cognitive psychology: complex work depends on holding intermediate ideas in mind, and interruptions impose a restart cost beyond the minutes they consume. Yet private offices are not a universal cure. Teams also need accessible collaboration, and some people prefer shared settings. The practical principle is choice: protect uninterrupted work while making it easy to seek help. The chair comparison usefully reframes spending as a lifecycle cost, though comfort and inclusion matter more than one branded purchase.
Treat programmers as experts, not as hands waiting for orders
Autonomy attracts experts. Developers want authority over decisions within their technical expertise, rather than managers issuing commands without understanding the work. Spolsky recalls managers at Juno dictating a small interface detail without hearing the designer's reasoning. He contrasts that with a debate at Microsoft over a proposed visual programming project: sustained technical arguments helped stop a direction the team believed was flawed.
Culture is part of the offer. Programmers also care whether colleagues are decent, whether technical disagreements are settled on their merits, and whether the product feels worthwhile. A company need not manufacture glamour, but it should explain what is interesting or useful about its work. Pay still needs to be fair and competitive. It is simply a weak substitute for autonomy, good colleagues, and a workplace where technical judgment counts.
This argument aligns with self-determination theory, which treats autonomy and competence as central sources of durable motivation. In knowledge work, decision authority also improves information flow because practitioners often see technical constraints first. Still, autonomy without clarity can become abandonment, especially for junior staff. The strongest version is bounded discretion: define goals and constraints, then trust specialists to choose methods. A compelling mission helps, but it should never be used to excuse low pay or chaotic management.
Use resumes to order interviews, never to decide who can code
A resume is a weak signal. It can reveal clues worth investigating, such as personal projects, enthusiasm for programming, clear writing, or a carefully tailored application. It may also show experience with technically demanding work. Spolsky's screening process considers signals like these, along with evidence of intellectual ability, selectivity, and varied experience that could bring new perspectives.
Do not confuse clues with proof. A prestigious school, a high GPA, or a fashionable language cannot establish that someone will be an effective developer. These signals are used to decide whom to contact first, not whom to hire. The same caution applies to keyword filters and extra application hoops: strong candidates may simply choose an employer that asks less of them before a conversation. Actual programming ability belongs in the interview process.
This is a useful distinction between screening and selection. Hiring research often calls the underlying issue construct validity: whether a measure actually captures the skill it claims to measure. A degree or polished letter may correlate with some useful traits, but neither demonstrates code quality. Structured work samples offer more direct evidence. The book's proxies also carry risks: school prestige and language fluency can reflect opportunity as much as ability. Treating them as tentative signals, then testing relevant skills consistently, limits that distortion.
Use phone screens to test candidates' claims before costly interviews
Start with a conversation. Spolsky's phone screen takes about 45 to 60 minutes and filters out many candidates who looked promising on paper. First, ask about the candidate's work and clarify what they personally did. A claim of two years using a language, for example, should withstand detailed questions about the actual project. Ask how they handled obstacles, not just what their job title was.
Then think together. A broad design problem, such as planning an online version of a familiar board game, lets the interviewer explore algorithms, data structures, and tradeoffs through dialogue. The candidate should also get time to ask about the company. This makes the call a two-way evaluation: it tests the applicant while giving them a chance to judge the job.
The phone screen's strength is not the phone itself but the shift from credentials to evidence and explanation. A common prompt gives interviewers a more comparable basis for judging candidates than free-form conversation alone. The format can reduce the influence of appearance, though accent, bandwidth, and disability-related access still affect communication. A fair process should offer reasonable alternatives and use a consistent rubric. The candidate's questions matter too: recruitment is a choice on both sides, not a one-way audition.
Demand sharp problem-solving and a record of finishing difficult work
Test the work directly. Spolsky's hiring standard combines intellectual ability with follow-through. Ask candidates to describe a substantial project, what they did when plans met resistance, and how they contributed to the result. Then have them write code during the interview. Simple exercises can expose whether basic programming is fluent; harder problems create a conversation about design, correctness, and performance rather than a quiz on memorized facts.
Make the decision clear. Several future peers should interview independently, and each should record a hire or no-hire judgment promptly. If the evidence is genuinely uncertain, the book advises declining rather than lowering the bar to fill a vacancy. It also warns against trivia, brain teasers, and questions unrelated to the work. Candidates should be treated respectfully throughout, whether or not they receive an offer.
A work sample is valuable because it narrows the distance between interview performance and the job itself. Asking candidates to explain their reasoning also reveals how they respond to feedback and ambiguity. But no single exercise is a complete measure of engineering skill: a narrow test of pointers or recursion may privilege one educational path over practical competence in modern systems. Multiple interviewers and consistent criteria reduce individual bias, while the final judgment should consider both technical evidence and the role's actual demands.
Remove developers who consume more team capacity than they contribute
Some output is negative. An underperforming developer may not merely work slowly; others may spend time repairing their code, explaining basic issues, or containing design mistakes. Spolsky recommends identifying who is thriving, who needs specific improvement, and who is unlikely to improve. Peer assessments can help a new manager locate concerns, but they should prompt investigation rather than serve as an automatic verdict.
Raw counts invite gaming. Lines of code or bug totals can be manipulated: developers can add blank lines, avoid reporting defects, or preserve obsolete code to improve a score. The book argues that knowledge workers adapt to the metric, often at the expense of the real goal. Where dismissal is impossible, leaders should keep harmful work away from production code and provide concrete coaching to people who can improve.
This is a sharp application of Goodhart's law: once a measure becomes a target, people can optimize the measure instead of the outcome. Software makes the problem especially visible because shorter code can be better code, and a bug count depends on whether anyone records the bugs. Peer judgment can detect contributions that metrics miss, but it is also vulnerable to popularity effects and groupthink. Specific performance expectations, documented examples, and a chance to improve make the human judgment more accountable.
Build shared purpose instead of bribing people to chase targets
Three management styles differ. Command-and-control relies on orders and punishment. The book argues that it is poorly suited to technical work, where specialists often know more about the problem than managers do. Incentive-based management pays people for measured outcomes, but encourages shortcuts and can displace the desire to do good work. Spolsky calls this the Overjustification Effect: an external reward can weaken an existing internal motive.
Alignment takes more work. The Identity Method aims to help employees see organizational goals as their own, then gives them enough information to make sound decisions. Shared meals and meaningful company stories can foster connection, but transparent business context matters too. For example, explaining how release timing affects the ability to hire gives a developer information for making a tradeoff, rather than a bonus that rewards speed regardless of quality.
The strongest insight is that motivation depends partly on what people believe they are doing and why. A shared purpose can coordinate judgment in situations where no bonus formula captures every consequence. But identity can turn coercive if belonging requires unquestioning loyalty or suppresses dissent. The best team culture makes disagreement safe and keeps goals visible. External rewards are not inherently harmful, especially for routine tasks, but they are a poor replacement for sound systems, clear expectations, and meaningful agency.
Stabilize the delivery process before piling features onto software
Build dependable habits. The Joel Test is a 12-question check on whether a software team has basic practices for producing and improving code. Its concerns include version control, repeatable builds, regular integration, bug tracking, current plans and specifications, quiet work, suitable tools, testers, code-based interviews, and usability checks. The point is not to worship a score, but to spot missing infrastructure that repeatedly wastes effort.
Fix defects early. Spolsky describes a shift from rushing through features and postponing bugs to making known defects the priority before adding more code. A bug found immediately is usually cheaper to fix than one discovered after release, when the original code and context may be distant. A team that tracks defects and keeps builds reliable can make more credible plans and respond faster when priorities change.
Checklists are powerful because they protect routine safeguards from memory lapses, especially under schedule pressure. The Joel Test turns broad software-process advice into questions a team can actually answer. Its limits matter: a high score cannot prove that a product solves a real customer problem, that code is secure, or that a team is healthy. Process indicators should prompt investigation, not replace judgment. The most useful checklist is one that leads to visible improvement rather than a badge.
Analysis
The book's most consequential claim is that hiring is not an HR function bolted onto a company. It is an operating system: candidate sourcing, interview design, workplace conditions, management behavior, and software practice all determine whether scarce talent can be found, retained, and effective. The obstacle-course metaphor captures this well. A company's hiring yield depends not only on its ability to identify talent, but on how many needless barriers it leaves in place.
The argument is strongest when it connects the economics of software products to the value of exceptional design. Copies are cheap, so the return on a better product can be unusually large. Yet the case for dramatically unequal developer productivity rests partly on a small, specific dataset of student assignments, and the book sometimes moves quickly from that evidence to claims about creative genius. Its lesson is best read as a reason to seek strong people, not as a precise formula for staffing or compensation.
The book also insists that selection should focus on demonstrated problem-solving and execution. That corrective remains valuable, especially against keyword matching and prestige-based hiring. However, its own resume signals, including selective schools and English polish, risk reproducing the very shortcuts it criticizes. Structured interviews, relevant work samples, and explicit criteria help make the process more consistent and fair.
Finally, the management argument is more than a recruiting tactic. Autonomy, trustworthy colleagues, and shared purpose help teams use distributed expertise. These ideas remain useful across technical workplaces, even as remote work changes what an office can provide. The underlying challenge is unchanged: create conditions where skilled people can do their best work, then maintain standards that prevent weak processes or harmful behavior from consuming the team's capacity.
Review Summary
Smart and Gets Things Done receives mixed reviews, with praise for its practical hiring advice and criticism of its outdated content and perceived elitist approach. Readers appreciate Spolsky's straightforward writing style and insights into developer motivation. However, some find the book's focus on hiring only top-tier talent unrealistic for many companies. Despite its age, many still consider it a valuable resource for tech hiring managers, offering useful tips on attracting and retaining skilled programmers. The book's emphasis on creating a positive work environment and understanding developer priorities is consistently highlighted as beneficial.
People Also Read
Glossary
Smart and Gets Things Done
Hiring for ability and executionA hiring principle that asks whether a candidate can reason well and reliably turn ideas into completed work. It discourages choosing people solely for credentials, technical keywords, or conversational charm. The standard is intentionally compact: interviewers should seek evidence of both intellectual ability and practical follow-through.
Brooks’ Law
More staff can delay deliveryA principle from software project management stating that adding people to a late project can make it later. New team members require orientation, while existing members spend time communicating and coordinating. It explains why a larger programming team does not automatically produce more finished software.
The Joel Test
A software-team health checklistA 12-question checklist for assessing basic software development practices. Its questions cover areas such as version control, repeatable builds, defect tracking, planning, testing, working conditions, tools, and usability. The score offers a quick diagnostic, not proof that a team will build a successful product.
Zero defects methodology
Fix known bugs before adding featuresA development approach in which resolving known defects takes priority over writing new code. The aim is to prevent a growing backlog of bugs from making schedules unreliable and fixes more expensive. It does not mean that software can literally contain no defects; it means the team avoids knowingly accumulating them.
Identity Method
Align people through shared purposeA management approach that seeks to connect employees' own sense of purpose with the organization's goals. Managers share relevant information and create conditions for people to make decisions that support the team, rather than relying mainly on orders or individual rewards. Its effectiveness depends on genuine trust and meaningful goals.
Econ 101 management
Managing through financial incentivesSpolsky's label for managing by attaching rewards or penalties to measured outcomes. It assumes people can be steered by adjusting incentives, but can encourage employees to optimize the measured target rather than the organization's real objective. In technical work, easily gamed measures may distort behavior and weaken intrinsic motivation.
Overjustification Effect
Rewards can weaken internal motivationThe possibility that an external reward reduces a person's existing internal motivation to perform an activity. In the book's management discussion, paying developers for a particular measured result can make the reward, rather than the quality of the work, feel like the reason for doing it. The concept warns against treating incentives as a universal solution.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.