Six stages from the fundamentals that outlast frameworks to running governed, agentic software work. Each stage says what you should be able to do, where to learn it from primary sources, and the mistake most people make there.
This is one route through the material, shaped by how we build at Nalaya. It is not the only one, and skipping ahead is allowed — the stages are ordered because later ones assume the earlier ones, not because permission is required.
Judge each stage by what you can build, not by what you have read.
What is still true after the framework you learned is dead?
Frameworks turn over every few years. The layer underneath them barely moves, and it is the layer that decides whether you can debug something you did not write.
The reference for how the web actually behaves. Not a tutorial site — a specification you can read.
Shell, git, debugging, and tooling. The things courses assume you picked up somewhere.
Free and complete. Read chapters 2, 3, and 7.
If you want the deep version, this is the honest reading list.
Common trapCollecting tutorials instead of finishing one broken thing. You learn debugging only by being stuck.
Think it through Learning is not compliance Active learning increases student performance in STEM
What changes when the user is not you?
The gap between a working demo and something a stranger can use is where most of the actual profession lives — error states, edge cases, deployment, and the second week after launch.
Role-by-role skill maps. Use it to find gaps, not as a checklist to complete.
Short, old, still correct on config, dependencies, and deployment.
The ten ways your first public app will be broken into.
Common trapRewriting the project instead of finishing it. The unfinished rewrite teaches you nothing the first version had not already offered.
Think it through Make an idea meet reality Running small experiments
How do you get reliable output from something non-deterministic?
Prompting is the entry point, not the skill. The real skill is building a system around a component that is fluent, confident, and sometimes wrong.
Practical and specific. Start here.
The other primary source. Compare where they disagree.
What can go wrong, catalogued by people whose job is to think about it.
Common trapTreating a fluent answer as a correct one. Fluency is the one thing these systems always produce.
Think it through AI assistance is not the same as learning Generative AI without guardrails can harm learning
How does a model answer about things it was never trained on?
Prompt engineering moved into context engineering: deciding what the model sees, from where, and in what structure. Retrieval got you documents. Graphs get you relationships between them.
Why naive chunking loses meaning, and a concrete fix.
Open implementation of graph-structured retrieval. Read the approach even if you build your own.
An open standard for connecting models to tools and data sources.
Common trapReaching for a graph because it sounds advanced. Most retrieval problems are a chunking problem wearing a costume.
Think it through Mapping assumptions Evidence reduces but does not remove uncertainty
What has to be true before you let software act on its own?
An agent is a loop with tools and a stopping condition. The engineering is almost entirely in the boundaries — what it may touch, what it must never do, and how you find out what it did.
The most grounded thing written on when not to build an agent.
Prompt injection is not theoretical. Read this before anything of yours touches untrusted input.
Common trapGiving an agent broad permissions because narrowing them is tedious. That trade is how incidents happen.
Think it through Autonomy needs governance, not just capability Agency does not guarantee control
Can approved work move overnight while people keep hold of the decisions?
The end of this track is not a smarter model. It is a governed production system: bounded tasks, scheduled execution, checks that produce evidence, and people who stay accountable for direction and risk.
The full write-up of this model, with the loop and the guardrails.
The measurement discipline underneath any claim that delivery improved.
Common trapAutomating a process nobody had defined. Automation makes an unclear process fail faster, not better.
Think it through Decision journaling Decisions and outcomes are different
Most products are built by some combination of these. Read them to find where you want to be useful, and what AI changed about each.
Between the people with the problem and the people building
Turns a vague complaint into a stated problem, a scope, and a way to tell whether it was solved.
What AI changedDrafting specs and summarising research got fast. Deciding which problem deserves a build did not.
At the boundary between the market and the roadmap
Understands the buyer well enough to know which promises are safe to make.
What AI changedOutreach and collateral are commodity now. Trust and technical credibility are the scarce parts.
Closest to the person actually using the thing
Builds the interface, and owns accessibility, performance, and state.
What AI changedGenerated components are competent and generic. Knowing why a layout breaks is still yours.
Where data and correctness live
Designs APIs and data models, and carries the consequences of both.
What AI changedBoilerplate collapsed. Schema decisions, consistency, and failure modes did not.
Across the seam, usually on smaller teams
Carries a feature end to end and understands the cost of each layer.
What AI changedThe most leveraged role in an agentic setup, and the easiest place to be shallow everywhere.
On a device with real constraints
Ships under app store rules, offline states, and battery limits.
What AI changedPlatform rules and release mechanics are unforgiving and poorly represented in generated code.
Where assumptions meet evidence
Finds what breaks before a user does, and makes it reproducible.
What AI changedGenerating test cases is cheap. Deciding what is worth testing is the whole job.
Under everything, noticed mainly when it fails
Owns pipelines, infrastructure, and the security posture of the delivery path.
What AI changedThe role agentic delivery depends on most — an autonomous pipeline is a security surface first.
Reading this page changes nothing on its own. Take the stage you are actually at, pick one outcome from its list, and build something small enough to finish that proves you can do it. Then move.