Zaniar Shokati

Most of us have been there: we buy books, queue up courses, and tell ourselves we’ll start building “after just one more chapter.” Weeks pass. We know more, but we haven’t shipped anything. That’s the endless learning loop—busy, safe, and strangely unproductive.

You don’t have to choose between reckless “learn on the job” and endless study. The sweet spot is simple: study with purpose, build early, and keep moving.

What the loop looks like

What the loop looks like

• “I’ll start after these five books.”
• “I need four full courses before I’m ready.”
• “Let me finish this last module… and the next one.”

Learning feels safe. Building exposes gaps. But those gaps are where real skill forms.

Two bad extremes to avoid

• Only learning by doing: Fine for low-risk work, but careless in safety-critical areas (e.g., embedded code for medical devices). There, you need strong theory and proper reviews.
• Learning everything before you code: You’ll never feel “ready.” Even one book can become a loop if you refuse to touch the keyboard.

Professional path: study seriously, implement early, and practice safely.

A simple system that works

1) One Chapter → One Build

After every major concept, create a new mini project (not the tutorial code). Keep it tiny; the goal is to turn ideas into muscle memory.

2) The 5–3–2 weekly rhythm

• 5 hours focused study (books, lectures, papers)
• 3 hours building a mini project using exactly one new idea
• 2 hours review and reflection (notes, reading others’ code, quick feedback)

This keeps learning and doing in balance.

3) One new thing at a time

If the “new thing” is vector search, don’t also pick a new web framework and a new cloud. Reduce the noise so the new concept sticks.

4) Start fast, finish clearly

• Start rule: begin coding after one solid lesson—no exceptions.
• Finish rule: you’re done when you can explain what you built and why in five minutes.

5) Measure progress like a pro

Track outcomes, not hours:

• Repos, notebooks, tests, and short write-ups
• One clear explanation someone else can follow
• Feedback you used to make a change

What to build (pick one and go)

• Generative AI: a CLI that drafts product descriptions and saves them to CSV
• Classical ML: a tiny classifier for your own emails (“actionable” vs “FYI”) with a confusion matrix
• Data engineering: a script that ingests a public CSV, cleans it, and writes summary stats to SQLite
• Vector search: index a folder of PDFs and return the top 3 matching passages for a question
• Computer vision: batch-resize images, then add a simple “find similar” feature using embeddings
• Embedded (sandboxed): simulate sensor data, implement a ring buffer, and log latency

Keep scope small. Ship ugly. Learn fast.

How to use LLMs without losing understanding

• Brainstorm: “Give me 5 micro-projects that use X.”
• Guide your reading: “Walk me through this source file and flag pitfalls.”
• Targeted help: “I’m hitting OOM here—suggest two alternatives.”

Avoid end-to-end answers that make you a spectator. You should still own the design and trade-offs.

When study must come first

In high-risk domains (medical, aviation, finance infra), do your homework, use simulations, follow checklists, and get reviews. You still practice, but you practice safely.

A one-week starter plan

• Day 1: Learn one chapter/module
• Day 2: Build a tiny project using only that idea
• Day 3: Read a similar open-source file and note differences
• Day 4: Add one feature or a test; remove one dependency
• Day 5: Write a short README (what you built, why, limits)
• Day 6: Ask for quick feedback; fix one issue
• Day 7: Pick the next concept and queue the next tiny build

Repeat weekly. You’ll stack real skills fast.

Start smaller than you think

If today is just:

print("Hello, World!")

print("Hello, World!")

Great. Then ask:

• What happens if I remove the parentheses?
• What if I change the quotes?
• How do I print two lines without repeating print?
• How do I write the output to a file?

Each question becomes a mini experiment. That’s how learning sticks.

Tools vs. understanding

Automation tools (like n8n and others) are useful, but teams hire people who understand why things work. Build your mental models first—data flow, failure modes, performance, correctness. Tools are faster when you already think clearly.

The short version (pin this)

• Learn a concept → build something small immediately
• Keep scope to one new idea
• Explain your work in five minutes
• Ask for feedback and improve
• Repeat next week

Study seriously. Build early. Reflect consistently. That’s how you escape the endless learning loop—and grow like a professional.