Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
The Missing README

The Missing README

A Guide for the New Software Engineer
Learn to ship reliable software, navigate team dynamics, and grow from new hire to trusted engineer.
by Chris Riccomini 2021 288 pages
4.40
437 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat your first months as an apprenticeship in shipping, not just coding

The job is broader than code. Programming is only one part of professional engineering. New engineers also need to learn how their company builds, tests, deploys, and operates software, and how teammates make decisions. The book charts a practical progression: learn the environment, make a small change, deliver useful features, participate in operations, and take responsibility for a project. Progress means becoming dependable across technical work, execution, communication, and leadership, not simply writing more code.

Start with safe responsibility. A small documentation fix or low-risk code change can teach the whole delivery path. Early contributions should build local knowledge and confidence, not prove that a newcomer can overhaul the system. The destination is the ability to deliver changes safely and work smoothly with a team.

Analysis

What's useful here is the shift from an individual skill model to a social one. A new engineer is learning the local system, but also learning how trust, responsibility, and information move through a team. That resembles apprenticeship in fields where judgment is learned through supervised practice, not lectures alone. The sequence also guards against a common mistake: interpreting slow early output as failure. Still, onboarding should not become a vague waiting period. Managers need to provide bounded tasks, timely feedback, and increasing responsibility so learning converts into contribution.

Experiment first, then ask questions that save everyone time

Learning needs feedback. The book describes four competence stages, from not knowing a skill is missing to performing it without much conscious effort. A new engineer's practical target is conscious competence: being able to do the work deliberately, even if it still takes effort. Front-load learning by reading team documents and code, but pair that study with experiments, debugging, small shipped changes, and shadowing experienced colleagues.

Ask with evidence. Search documentation, source code, and ticket histories, then set a time limit so research does not become solitary wheel-spinning. When asking for help, state the problem, what you tried, what you observed, and the impact. Prefer shared, asynchronous channels when possible, and save interruptions for urgent matters. Confidence also needs calibration: record real accomplishments to counter self-doubt, and actively seek feedback to counter overconfidence.

Analysis

The advice treats asking for help as a skill with a cost structure, rather than a test of intelligence. A concise account of experiments reduces the helper's search burden and gives the questioner a useful mental model. This resembles scientific practice: observations and failed attempts narrow the hypothesis space. The caution about confidence is valuable because novices often have incomplete maps of what they do not know. However, timeboxing must not become a ritual that delays urgent escalation. Teams should make the threshold for asking clear, especially when production risk or customer impact is involved.

Improve inherited code in guarded increments, not heroic rewrites

Mess is accumulated history. Software entropy is the drift toward disorder as requirements, technologies, and contributors change. Technical debt is a specific kind of shortcoming that makes future work slower or riskier. Like financial debt, it has principal and accumulating interest: workarounds spread and become harder to remove. Not every old or disliked design is debt. The useful question is whether it creates measurable future cost or serious risk.

Protect each change. Before altering legacy code, locate the relevant behavior, find a way to test it, make dependencies easier to control, and capture existing behavior with tests. Then make the functional change in small steps. Keep cleanup separate from feature work where practical, and improve adjacent code opportunistically. Large rewrites are expensive bets: a Twitter experiment described in the book was expected to take six months but took eighteen, including a long retirement of the old system.

Analysis

The debt metaphor is strongest when it forces a concrete conversation about interest: which feature work is being slowed, which failures are becoming more likely, and what would repayment buy? Without those specifics, the label can become a complaint about taste. Incremental change is also a form of risk containment. Small, reversible steps let teams learn from each change instead of betting on a grand design. Yet incrementalism is not always sufficient. Some systems do need replacement, but the case should rest on evidence, migration costs, and a credible transition plan rather than aesthetic frustration.

Build for the 3 a.m. operator, not only the happy-path user

Production is unpredictable. Users send malformed inputs, networks fail, and processes run out of resources. Operable code anticipates failure and helps people understand and control a running system. Validate inputs early, constrain values with types where possible, prefer immutable state, and use precise errors. Retrying remote work requires care: backoff gives a failing service breathing room, while random jitter helps prevent many clients from retrying together. Idempotent operations make retries safer because repeating the same request does not repeat its effect.

Make behavior visible. Use standard logging, metrics, and distributed traces to expose what the software is doing. Validate configuration at startup, provide sensible defaults, and avoid clever configuration formats. A 2017 AWS S3 outage began when an operational command removed too much capacity; safeguards were added so a mistaken input could not remove it so quickly. Good tools should limit the damage a human error can cause.

Analysis

This is safety engineering applied to software: assume errors will occur, then design barriers that limit their consequences and make recovery legible. The emphasis on operability also reframes observability as part of a feature, not a dashboard added after launch. A system that cannot explain its state transfers uncertainty to its operators. There is a real trade-off, though: more logging and metrics can cost performance, money, and privacy. Useful instrumentation is selective enough to guide action, while avoiding secrets and noisy signals that obscure the failure.

Treat every dependency and test as a maintenance contract

Small additions can widen risk. A dependency is code your project relies on, and transitive dependencies are the libraries pulled in by those direct choices. The removal of the tiny JavaScript package left-pad once broke thousands of projects through dependency chains. Inspect the full dependency tree, add only libraries whose value justifies their upkeep, declare what your code uses directly, and pin resolved versions so builds remain reproducible. Version numbers help communicate whether a change promises compatibility, but those promises are not perfect.

Test for consequential behavior. Unit tests should be fast and isolated; integration tests check components working together, while system and performance tests cover broader behavior. Prioritize tests by likelihood and impact of failure, not a coverage target. Flaky tests lose credibility. Control randomness and time, avoid remote calls in unit tests, isolate test data, and clean up resources so one run does not contaminate another.

Analysis

Dependencies and tests are both promises about the future. A dependency promises useful behavior but also imports its release practices, compatibility assumptions, and failure modes. A test promises that a failure signal means something. When either promise is unreliable, engineers pay with debugging time and diminished trust. The book's skepticism is not an argument for avoiding libraries or pursuing perfect determinism at any cost. It is a prompt to make the trade visible. Some systems are inherently asynchronous, so the goal is controlled, informative uncertainty, not a fantasy of eliminating it.

Use reviews and design documents to distribute understanding, not approval

Reviews teach the team. Code review can catch mistakes, but its deeper value is spreading knowledge, recording decisions, and making production code familiar to more than one person. Submit small changes with context, tests, and a clear description. Reviewers should first understand the reason for the change, then distinguish required fixes from optional suggestions and minor style notes. Respectful, specific feedback keeps the review about the work rather than the author's worth.

Design begins with the problem. For consequential changes, define the need and scope before choosing a solution. Research alternatives, run small experiments, and write down trade-offs. A design document makes gaps visible and gives affected teams a chance to respond before implementation is entrenched. The process should scale to the decision: a small change may need a short note, while a major architectural shift deserves broader discussion. Keep the document aligned with what is actually built.

Analysis

These practices turn engineering knowledge into a shared asset rather than private expertise. That matters because software teams face turnover, on-call handoffs, and decisions whose rationale is otherwise easy to lose. Writing is particularly powerful because it exposes ambiguity before code hardens it. Still, documentation and review can become bureaucracy if the process is heavier than the risk. The right test is whether a practice improves understanding, decision quality, or safety. A document that no one reads, or a review that only checks formatting, is process without much value.

Deliver changes in stages, and restore service before solving the mystery

Delivery is a chain. Code must be built into a versioned package, published as an immutable release, deployed to an environment, and rolled out to users. Automate these steps where possible, avoid deployment-order dependencies, and monitor health as traffic shifts. Feature flags, canary releases, and dark launches can reduce exposure: a dark launch sends real traffic through new code while withholding its results from users. These techniques add operational complexity, so reserve them for changes whose risk warrants the machinery.

Incidents have priorities. First assess impact and severity, coordinate the response, and mitigate harm. Then investigate and fix the underlying issue, followed by a blameless review and tracked corrective work. In one incident, a data connector stopped loading warehouse records because a message header triggered a deserialization problem. The team isolated the affected stream to restore most data first, then found the cause. Restoring service came before a complete explanation.

Analysis

The delivery model separates a technical fact, code has been installed, from the user-facing fact, the change is safe and working. That distinction is central to reliable release practice. Incident response follows a similar logic: reduce immediate harm before pursuing causal completeness. This is a disciplined response to uncertainty, not an excuse to skip diagnosis. Staged rollouts work only when teams define health signals in advance and can actually reverse a change. Otherwise, gradual exposure merely spreads a failure more slowly while creating confidence without control.

Keep systems evolvable by refusing complexity you cannot justify

Simplicity preserves options. Requirements change, but speculative flexibility often creates abstractions no one needs. The book's YAGNI principle means avoiding features, optimizations, and general-purpose interfaces until a real requirement justifies them. A small, specific API is easier to understand than one designed to anticipate every possible use. Make constraints visible, use familiar patterns, and organize code around business domains so a change has a limited blast radius.

Data deserves the same care as code. Isolate databases when practical, define explicit schemas, and manage schema changes through versioned migration tools. A database field may be consumed by reports or other services even when those consumers are invisible to its owner. Preserve compatibility or provide a controlled migration path. An explicit schema can feel slower to change, but that friction forces teams to consider existing records and downstream users before a change breaks them.

Analysis

The deeper principle is that adaptability comes less from predicting the future than from limiting the cost of being wrong. Minimal designs are easier to revise because fewer assumptions have become dependencies. This connects to option value in economics: keeping a decision reversible can be worth more than building every possible future path now. Simplicity is not the same as minimal line count, however. A well-chosen schema or interface may add structure while reducing ambiguity. The practical measure is whether the design makes likely changes safer without burdening every user with hypothetical flexibility.

Make planning and management conversations produce clarity, not ceremony

Agile is a feedback loop. Scrum uses short work cycles, planning, brief progress check-ins, reviews, and retrospectives. Kanban visualizes work and limits how much is in progress. Neither framework is a virtue by itself. Use the practices that help the team deliver useful software, surface blockers, and adjust to new information. Good user stories explain who benefits and why; acceptance criteria make completion testable. Estimates are aids to planning, not precise forecasts.

Manage the relationship actively. Use one-on-ones for feedback, growth, and obstacles rather than routine status recitation. Track progress, plans, and problems so important work is not left to memory. Discuss measurable goals with a manager, and give feedback using observable behavior and its impact instead of assumptions about motives. If the relationship or work environment stays harmful despite direct attempts to improve it, seek support or consider a team change.

Analysis

Planning rituals are useful when they expose reality: overloaded capacity, unclear ownership, work stuck in review, or goals that no longer matter. Their failure mode is metric substitution, where teams optimize points completed or meeting compliance instead of customer outcomes. The same distinction applies to management. Regular conversations create access, but only candid, specific feedback makes them developmental. There is also an asymmetry of power: an employee cannot repair every management failure through better communication. The advice to raise concerns is strongest when paired with credible paths to support and change.

Grow breadth and depth, make impact visible, and protect your stamina

Build a T-shaped career. A T-shaped engineer can contribute across several areas while developing deep expertise in one. Breadth helps engineers understand system interactions and collaborate across teams; depth gives them the judgment to solve difficult problems. Seek projects, mentoring, reviews, and engineering programs that build both. Promotions depend on sustained impact and broader responsibility, not simply time served or technical cleverness. Learn the promotion criteria early, gather specific feedback, and make contributions visible, including essential work that produces no code commit.

Make growth sustainable. Changing jobs can broaden experience, but frequent moves may prevent an engineer from seeing the long-term consequences of decisions. Staying too long can also lead to stagnation. Choose deliberately. The book cites research reporting that one night of sleep deprivation reduced novice developers' implementation quality by 50 percent. Long hours are not a sound career strategy; rest and vacations protect the capacity to keep learning.

Analysis

Career development here is framed as accumulating judgment, not collecting titles or technologies. Breadth helps an engineer notice interactions; depth helps distinguish a real systems problem from a superficial symptom. Visibility matters because organizations cannot reward contributions they do not recognize, though visibility should not be confused with self-promotion detached from results. The warning about invisible coordination work is especially important: teams often rely on glue work while promotion systems count more legible outputs. Sustainable pacing is not merely personal wellness. It preserves attention, learning, and decision quality across a career.

Analysis

The Missing README is a field guide to the parts of software engineering that code alone cannot teach. Its structure follows a new engineer from onboarding through production responsibility, design, planning, management, and career development. The chapters are deliberately practical, using incidents and workplace stories to make abstract norms memorable: a damaged source repository, a misleading file upload experience, a dependency failure, and a production data outage all show how engineering judgment is formed under real constraints.

The book's central argument is that professional engineering is a sociotechnical discipline. Quality depends not only on algorithms, but on how code is tested, reviewed, released, observed, and understood by people. That makes communication and operational competence technical concerns rather than optional soft skills. Its strongest recurring idea is reversibility: make small changes, preserve compatibility, keep releases immutable, use gradual rollouts, and create systems that fail safely. These practices shrink the cost of uncertainty.

The authors also make a useful distinction between principles and ceremony. They endorse Agile planning, design documents, code reviews, and metrics, while repeatedly warning that each can become wasteful when detached from its purpose. A process is valuable when it improves feedback, shared understanding, or risk control. This pragmatic stance gives the guide flexibility across teams, although its examples are rooted in fast-growing technology companies and may not map neatly onto every organization.

The book is most valuable as a map, not a complete technical reference. Its breadth means many topics receive concise treatment, and its advice sometimes assumes a team with managers, review systems, and operational tooling. Still, it supplies a durable mental model: learn the local environment, expose uncertainty early, make consequential work legible, and treat production behavior as part of the design. The result is a definition of competence measured not by isolated coding speed, but by the ability to help a team deliver and sustain useful software.

Summary in 30 Seconds
Professional software engineering includes testing, deployment, operations, communication, and code, so learn the team's tools and delivery process before taking on larger work. Protect existing behavior with tests and make changes in small, reversible steps. Limit dependencies, monitor production, and restore service before investigating an incident fully. Use reviews and planning to share context and surface risks. Build both broad system knowledge and deep expertise, while protecting sleep: one study found sleep deprivation cut novice developers' implementation quality by 50 percent.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.40 out of 5
Average of 437 ratings from Goodreads and Amazon.

The Missing README receives overwhelmingly positive reviews, with readers praising its comprehensive coverage of software engineering practices. Many describe it as an essential guide for new developers, bridging the gap between academic knowledge and industry experience. Experienced engineers also find value in its concise explanations and practical advice. Reviewers appreciate the book's clear organization, helpful summaries, and additional resource recommendations. Some note that while it's most beneficial for those new to the field, it serves as a valuable reference for professionals at all levels.

Your rating:
4.63
128 ratings
Want to read the full book?

Glossary

Conscious competence

Effortful but capable performance

One stage in a four-part model of learning. A person at this stage knows what they do not yet do automatically, but can perform the task correctly with deliberate effort. The book presents this as a practical early-career goal: learn the work well enough to contribute reliably before expecting it to feel effortless.

Technical debt

Future cost from code shortcomings

A shortcoming in existing software that creates future work, slows development, or risks a serious failure. Its principal cost is the original problem; its ongoing interest is the added complexity of workarounds that spread as the system changes. A design someone dislikes is not automatically technical debt unless it creates meaningful cost or risk.

Semantic versioning

Compatibility-signaling version numbers

A package versioning convention that uses major, minor, and patch numbers. Under its stated expectations, a patch release contains compatible fixes, a minor release adds compatible features, and a major release may break compatibility. Prerelease labels can identify versions still under evaluation. The convention helps developers compare releases, although actual compatibility still depends on project discipline.

Idempotent operation

Repeatable without added effect

An operation that can be applied more than once while leaving the system in the same effective state as applying it once. Adding an item to a set is a simple example. In distributed systems, idempotency can make retries safer when a client cannot tell whether a request completed before a network failure.

Service level indicators (SLIs)

Measured service health signals

Quantitative measurements used to assess a service's behavior, such as its error rate, request latency, or request volume. Service level objectives set targets for these indicators, while service level agreements describe commitments and consequences associated with missing targets. Together, these measures help teams assess health and prioritize operational incidents.

Dark launch

Production traffic without user-visible effects

A release technique that sends real production requests through new code while withholding its results from users. Teams can compare the new system's behavior with the live system and identify discrepancies under realistic traffic. Dark launches require care around duplicated side effects, analytics, and data writes, because the new code is still executing.

You Ain’t Gonna Need It

Avoid speculative features

A design principle advising engineers not to build features, abstractions, or optimizations before a real need appears. Unused flexibility still costs time to implement, understand, test, and maintain. The principle favors a simple working design that can be extended when evidence or requirements justify the added complexity.

T-shaped

Broad skills, one deep specialty

A description of an engineer with useful working knowledge across several areas and strong expertise in at least one. Breadth supports collaboration, system-level understanding, and cross-team problem solving. Depth enables specialized judgment. The balance can shift as teams and organizations grow, but both dimensions help engineers contribute beyond a narrow task boundary.

Objectives and key results (OKRs)

Goals paired with measurable outcomes

A goal-setting framework in which an objective describes a desired outcome and a small set of key results measures progress toward it. Key results should describe evidence of success, not prescribe a task list. Organizations often align individual, team, and company goals, while deciding whether targets represent firm commitments or ambitious stretch goals.

Situation-Behavior-Impact (SBI) framework

Evidence-based feedback structure

A format for giving feedback by describing the situation, identifying an observable behavior, and explaining its impact. It reduces reliance on assumptions about a person's motives or character and helps keep discussion concrete. The framework can be used for corrective or positive feedback, with the aim of making the consequences of behavior clear.

About the Author

Chris Riccomini is the author of The Missing README. While specific biographical information is not provided in the given content, it can be inferred that Riccomini is an experienced software engineer with extensive industry knowledge. His book demonstrates a deep understanding of software development practices, team dynamics, and career progression in the tech industry. Riccomini's writing style is described as clear, concise, and accessible, making complex topics understandable for novice engineers. His work is highly regarded by both new and seasoned professionals, suggesting that he has successfully distilled years of experience into practical, actionable advice for software engineers at various career stages.

Download PDF

To save this The Missing README summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.32 MB     Pages: 17

Download EPUB

To read this The Missing README summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.35 MB     Pages: 22
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...