12_portfolio/ — The Portfolio Ladder¶

This folder is the load-bearing wall of the fortress. Every other layer — the language study, the DSA drills, the systems-programming reps, the ML-inference deep-dive — exists to feed these seven public artifacts. If M13 arrives and the rest of the roadmap is pristine but this folder is empty, the year failed. If M13 arrives and only this folder shipped, the year succeeded. That is the asymmetry to internalize before you read another line.

A portfolio is not a “showcase of your learning.” A portfolio is a credibility instrument. A recruiter scrolling your GitHub for 90 seconds is not evaluating your knowledge — they are evaluating whether you finish things, whether the things you finish are non-trivial, and whether the writing around the things you finish signals a mind that can hold a system in its head. Every rung below is engineered to answer one of those three questions louder than the previous rung.

The Doctrine (read once, re-read at every plateau)¶

A portfolio piece that is not publicly visible does not exist. Local repos, private gists, and “I’ll clean it up later” folders are worth zero. If it is not on a public URL a stranger can reach in one click, it is not shipped.
A portfolio piece without a README that a stranger can execute in 5 minutes does not exist. Assume the reader has 90 seconds of patience and no context.
**Each rung must send a specific signal — not “I know C.” “I know C” is not a signal; it is a claim. “I sustained 100k RPS on a 4-core laptop with a single-threaded epoll loop, here’s the benchmark methodology” — that is a signal.
The specificity gradient is monotonic. Every rung is more specific than the one below it. You never regress toward “generic C developer” once you have shipped a rung.
Two rungs are non-negotiable. See 08_hard_gates_and_signals.md. If only two things ship in 13 months, they must be Rung 5 and Rung 6.

The Specificity Gradient¶

Each rung is calibrated to strip one more layer of generality off your public identity. By Rung 7 you should be un-Googleable except as “the person who writes fast C for [thing].”

Rung	Public identity after shipping
1	“Someone who is starting to learn C seriously”
2	“Someone who can write a small C library”
3	“Someone who does DSA in C, not Python”
4	“Someone who understands the Unix process model”
5	“Someone who can build the concurrency substrate of a real service”
6	“Someone who thinks like an inference-engine engineer”
7	“Someone who ships C alongside senior maintainers”

Notice: the identity narrows and sharpens. Rung 1 is a beginner claim; Rung 7 is a hireable-at-senior-adjacent claim. There is no rung that says “generic mid-level C developer” — that identity has no market and this ladder deliberately does not build toward it.

The Visual Ladder¶

                              ┌────────────────────────────────┐
     M13 ──────────────────►  │ RUNG 7: Merged OSS PR + Blog   │  "ships with senior maintainers"
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
     M11 ──────────────────►  │ RUNG 6: SIMD GEMM Benchmark    │  ◄── HARD GATE #2
                              │ (naive → blocked → AVX2/NEON)  │      "ML-infra doors open"
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
      M9 ──────────────────►  │ RUNG 5: epoll HTTP/1.1 Server  │  ◄── HARD GATE #1
                              │ (100k RPS, 24h leak-free)      │      "systems roles plausible"
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
      M7 ──────────────────►  │ RUNG 4: Mini-Shell (nsh)       │  "understands Unix process model"
                              │ (fork/exec/pipes/signals/jobs) │
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
      M5 ──────────────────►  │ RUNG 3: NeetCode-75 in C       │  "DSA in C is routine"
                              │ (75/75, complexity annotated)  │
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
      M3 ──────────────────►  │ RUNG 2: libprep           │  "can design a small library"
                              │ (vec/str/hash/heap/deque)      │
                              └────────────────┬───────────────┘
                                               │
                              ┌────────────────┴───────────────┐
      M1 ──────────────────►  │ RUNG 1: Toolchain Journal      │  "ships from week 1"
                              │ (gdb + ASan writeups + CI)     │
                              └────────────────────────────────┘

The ladder has an unusual property: the gaps between rungs are not equal in time OR in effort. Rung 5 costs more than Rungs 1-4 combined. Rung 6 costs about as much as Rung 5. Rung 7 is smaller in code but has the longest tail in social work (finding an issue, engaging the maintainer, iterating on review). Plan accordingly.

HARD GATES (read in ORANGE)¶

🟧 HARD GATE #1 — Rung 5 (epoll HTTP server) must be publicly shipped by end of Month 9. If M9 closes without Rung 5 in a public repo with a benchmark graph, invoke the reset protocol in 13_discipline/. This is not negotiable, not deferrable, not “I’ll do it in M10 instead.” The ladder is time-locked here because M10-M13 are load-bearing for Rung 6 and Rung 7.

🟧 HARD GATE #2 — Rung 6 (SIMD GEMM benchmark) must be publicly shipped by end of Month 11. Rung 6 is the résumé line that opens ML-infra roles. If M11 closes without a public benchmark writeup showing your matmul within 3x of OpenBLAS, the year’s positioning collapses back to “generic C developer” — a market with 100x more supply than demand.

Details, reset protocols, and the “if only 2 things ship” clause live in 08_hard_gates_and_signals.md.

Month-by-Month Publishing Map¶

Month	Rung shipping	Feeder folders
M1	Rung 1 (Toolchain Journal)	`01_refresher_and_toolchain/`, `11_tools_setup/`
M2	(Rung 2 in-flight)	`02_c_language_deep/`, `03_memory_and_pointers/`
M3	Rung 2 (libprep)	`03_memory_and_pointers/`, `04_dsa_in_c/`
M4	(Rung 3 in-flight)	`04_dsa_in_c/`
M5	Rung 3 (NeetCode-75 in C)	`04_dsa_in_c/`
M6	(Rung 4 in-flight)	`05_systems_programming/`
M7	Rung 4 (Mini-Shell)	`05_systems_programming/`
M8	(Rung 5 in-flight)	`06_concurrency_and_networking/`
M9	Rung 5 (epoll HTTP) 🟧	`06_concurrency_and_networking/`
M10	(Rung 6 in-flight)	`07_applied_c_ml_inference/`
M11	Rung 6 (SIMD GEMM) 🟧	`07_applied_c_ml_inference/`
M12	(Rung 7 hunting + drafting)	`08_production_and_mastery/`, `10_communities/`
M13	Rung 7 (Merged OSS PR)	`08_production_and_mastery/`, `10_communities/`

Notice the cadence deliberately front-loads small wins and back-loads heavy artifacts. Rungs 1-3 build the momentum and the writing muscle. Rungs 4-6 are where mastery is proved. Rung 7 is where mastery is witnessed by strangers with commit access.

How to Read This Folder¶

Read the files in numeric order the first time. On subsequent reads, jump straight to the rung you are currently shipping and re-read the “Common failure modes” section — that is where most of the calibration lives.

01_rung_1_toolchain_journal.md
02_rung_2_libprep_containers.md
03_rung_3_neetcode75_in_c.md
04_rung_4_mini_shell.md
05_rung_5_epoll_http_server.md 🟧
06_rung_6_simd_gemm_benchmark.md 🟧
07_rung_7_oss_merged_pr.md
08_hard_gates_and_signals.md

Return to ../README.md · Next: 01_rung_1_toolchain_journal.md