The Continuous Learning Loop

Day 90 is not the finish line; it is the point at which most people stop. The field moves fast enough that a portfolio built this quarter reads as dated within a year, and the specific advantage you built during the 90-Day Plan — being current — decays unless you maintain it. This page describes four nested loops that keep it current at a cost of roughly two to four hours a week, plus a few concentrated pushes per year.

The design principle: the loops nest, so the small one feeds the large one. Weekly notes become the raw material for monthly experiments; monthly experiments become quarterly portfolio updates; a year of quarterly updates becomes a conference talk. Nothing is busywork, because every output is an input to the next loop up.

Loop	Cadence	Output	Failure mode
Read	Weekly, 60–90 min	A public note summarizing one paper, advisory, or writeup in your own words	Silent collection: saving links you never read, notes nobody sees
Build	Monthly, 3–4 hours	One new attack vector applied to your own agent, with the result recorded	Reading about techniques without ever running one
Refactor	Quarterly, one day	Updated portfolio and refreshed framework mappings	Portfolio rot: the repo still describes what you did a year ago
Ship	Annually, weeks	One conference talk or one meaningful open-source contribution	Perpetual preparation; never actually submitting

Weekly loop: summarize one thing publicly

Why it exists. Summarizing in your own words is the cheapest available test of whether you understood something. Bookmarking is not learning; it is deferral. Making the note public adds a small, useful pressure to be correct.

Time budget. 60–90 minutes, one fixed slot. Same day, same time, treated as an appointment.

The output. One short public note — a repo file, a blog post, a thread. Three parts, nothing more:

What the source claims, in your own words, in under 200 words
Why it matters for agent systems specifically
What you would test, or what you now doubt

Surviving a busy quarter. Cut the scope, not the cadence. A three-sentence note is a valid week. The habit is the asset; the depth is negotiable. Missing two consecutive weeks is how the loop dies, so protect the streak over the quality.

What to read. Prioritize in this order: an advisory affecting something you actually run, a technical writeup of a real incident, a paper with reproducible results, then everything else. Broad survey posts are the lowest-value category — they summarize what you should be reading directly.

Publishing the note serves the visible network move at zero extra cost. Fifty-two honest weekly notes are a stronger professional signal than fifty-two opinion posts, and they are far easier to write because the source does the thinking about novelty.

Monthly loop: apply one new attack vector

Why it exists. Reading about an attack and executing one are different skills, and only the second survives an interview. This loop is what keeps your hands calibrated.

Time budget. One 3–4 hour session per month. Block it as a half-day, not four scattered hours.

The output. A dated entry in your own evaluation repo containing: the vector, where you learned about it, how you adapted it to your agent, whether it worked, and what control stopped it or would have. Add the successful ones to your regression suite so they run permanently.

Where the vectors come from. Your own weekly notes. This is the nesting: four weeks of reading produces at least one technique worth trying. Cross-reference against OWASP Agentic Threats and MITRE ATLAS so your coverage is systematic rather than driven by whatever was popular that month. The mechanics live in Lab 3 and Red Team Tools.

Surviving a busy quarter. Reduce to one vector, tested crudely, result recorded in two sentences. A negative result recorded is worth more than a perfect experiment skipped.

Every experiment in this loop runs against your own agent, in your own environment. Do not test new techniques against your employer’s production systems without written authorization through the proper channel, and never against a third party’s system. The convenience of a realistic target is never worth the consequence.

Quarterly loop: refactor the portfolio

Why it exists. Two things rot on a predictable schedule: your code’s dependencies and your framework mappings. Guidance documents get revised, regulations phase in, and taxonomies renumber. A portfolio that cites a superseded version of a framework signals that you stopped paying attention — which is worse than not citing one at all.

Time budget. One focused day per quarter.

The output. A quarterly pass covering:

Dependencies updated; the labs still run on a clean checkout
READMEs rewritten to reflect what the project does now, not what it did at launch
Framework mappings re-verified against the current published versions of OWASP, ATLAS, NIST AI RMF, ISO 42001, and EU AI Act obligations
The quarter’s monthly experiments folded into the evaluation suite
One artifact retired — the weakest one. A portfolio of three strong items beats six uneven ones
Positioning statement re-read: does it still describe the job you want?
Risk register refreshed; see Lab 5

Surviving a busy quarter. Do only the framework mappings and the dependency update. Those are the two that actively mislead a reader when stale. Everything else can slip a quarter without damage.

Annual loop: ship something that outlives you

Why it exists. Everything above is maintenance. This loop is the one that changes your position in the field, because it puts your name on something other people use or cite.

Time budget. Several weeks of evenings, concentrated in one part of the year. Pick the part deliberately — usually aligned to a CFP deadline you have already identified.

The output. One of:

A delivered conference talk, at any venue, including a local meetup
A merged, non-trivial contribution to an open-source agent or security tool
A published assessment of a real system, disclosed responsibly
A community working-group deliverable you meaningfully co-authored

Surviving a busy year. Downgrade the venue, not the act. A 20-minute talk at a local meetup counts. A merged documentation overhaul on a widely-used framework counts. The failure mode here is not shipping something small — it is spending the year preparing for something large and submitting nothing.

Building a personal knowledge base

Notes that are useful in a year look different from notes that are useful today. The difference is almost entirely about what you write down.

Write this	Not this
The problem the technique solves, in one sentence	A copy of the abstract
Your own explanation, in your own words	A quote you did not process
A concrete example you constructed	The paper’s example
What surprised you, and what you had believed before	Nothing — this is the highest-value line and most people skip it
The link, with the date you read it	The link alone
A tag naming the boundary or threat class it relates to	An untagged file in a folder called `notes`

Three rules that make a knowledge base survive:

One file per idea, not one per source. Ideas get revisited; sources do not.
Write for yourself in eighteen months, who will not remember the context you have right now.
Make it searchable and keep it in one place. The tool does not matter. Splitting across four tools does.

If you publish the notes, you get a fourth benefit: you will write them more carefully, and other people will correct you.

Choosing sources without drowning

The feed is infinite and mostly redundant. A small number of high-signal sources beats a large feed, reliably.

Tier	What it is	How many
Primary	Advisories and release notes for tools you actually run	All of them, for your stack only
Primary	Official framework and regulator publications	3–5, checked quarterly not daily
Secondary	Individual practitioners whose technical writeups have taught you something before	5–10 people, no more
Secondary	One or two community channels — an OWASP working group, one focused mailing list	1–2
Ambient	General news about AI	Deliberately minimal

A working test: if a source has not changed what you do in six months, remove it. Also worth internalizing — most “breaking” AI security news is a restatement of a known class of problem in a new product. You will recognize this once you have a taxonomy in your head, and you will stop spending attention on it.

Pull, do not push. Notifications turn a learning practice into an interruption practice. Check sources on your schedule, in your weekly slot, and let everything else wait. Nothing in this field requires a response within an hour unless it is your own production incident.

Burnout and sustainable pace

This deserves saying plainly. Security work carries a chronic low-grade anxiety — the sense that something is always unhandled — and AI security adds the feeling that the ground is moving. Both are real. Neither is fixed by working more.

What actually helps:

Accept that you cannot be current on everything. Nobody is. The people who look current are deep in a narrow area and comfortable being ignorant elsewhere.
Pick a lane. Depth in one of the five roles beats shallow coverage of all five, both for your career and for your peace of mind.
Keep the loops small enough to survive a bad month. A practice you abandon under load was designed wrong.
Separate work security from career security. Doing your job well and building your public profile are different activities; do not let one silently consume the evenings you allocated to the other.
Take real breaks between concentrated pushes. A conference talk costs weeks; schedule recovery afterwards rather than immediately starting the next thing.
Notice dread as a signal. If the weekly note has become something you avoid, the problem is scope, not discipline. Cut it to three sentences and continue.

The measure of this system is not how much you cover. It is whether you are still running it in two years.

Signs you have plateaued

Sign	What to do
Every new writeup feels like something you already knew	Move up a layer — go from techniques to architecture, or from architecture to governance. See Skill Tree
Your monthly experiment always succeeds	Your test targets are too easy. Harden your own agent, then attack the hardened version
Your portfolio has not changed in two quarters	Run the quarterly refactor you skipped; retire the weakest artifact
You are reading a lot and building nothing	Skip a weekly read cycle and spend it building instead. Reading is the easier habit and it crowds out the harder one
You cannot explain your work to someone outside security	Practice Layer 5; this gap caps your seniority more than any technical gap
Nobody has disagreed with you in months	You are publishing safely. Take a position with a real claim in it
You have no idea what you would talk about at a conference	You have stopped generating original results. Return to the monthly loop with a harder target
The job feels routine but you are not being given harder problems	You are ready for a different scope of role — revisit Choosing Your Path and What Employers Screen For

Plateaus are normal and recurring. The people who stay in this field are not the ones who never plateau — they are the ones who notice within a quarter and change one variable.

Interview Preparation