Learn enough code

Learn: One language, properly enough to read and change other people's code. Python or JavaScript — pick the one your colleagues use.

Build: A small utility you personally need. A file renamer, a CSV cleaner, a script that checks whether a site is up.

Prove: It runs from your terminal, handles a bad input without crashing, and someone else could run it from your README.

About 10 hours.

Connect to a model

Learn: API calls, keys kept out of your code, streaming, and what a token costs you.

Build: A command-line tool that takes text in and returns something useful. Not a chatbot — a thing with one job.

Prove: It handles a rate limit and a timeout without falling over, and you can state its cost per run.

About 14 hours.

Give it knowledge

Learn: Chunking, embeddings, vector search, and why a threshold matters more than the model choice.

Build: Retrieval over documents you actually care about — your notes, your company handbook, a codebase.

Prove: It answers three real questions with citations, and correctly refuses a fourth it has no source for.

About 18 hours.

Give it tools

Learn: Tool schemas, the agent loop, step budgets, and where to put the human.

Build: An agent with exactly two tools and one irreversible action behind a confirmation.

Prove: It completes a multi-step task, and you can show the log of what it decided and why.

About 20 hours.

Make it reliable

Learn: Eval sets, regression testing on non-deterministic output, guardrails, and cost control.

Build: A test set of twenty real cases, run automatically against every change.

Prove: You can show a change that broke something and the test that caught it.

About 22 hours.

Put it in front of colleagues (if your goal is job)

Learn: Deployment, secrets, access control, and how to explain it to someone who did not build it.

Build: Deploy it somewhere your team can reach, with a page explaining what it does and does not do.

Prove: Three colleagues used it in a week without you sitting next to them.

Build the portfolio that gets read (if your goal is switch)

Learn: What hiring managers actually look for: judgement, not tool lists.

Build: Three case studies, each with a link, the problem, what failed first, and what you changed.

Prove: Someone in the industry read one and asked you a follow-up question about a decision.

Get it in front of ten users (if your goal is product)

Learn: Onboarding, instrumentation, and the difference between usage and value.

Build: A version strangers can sign up for, with one metric you actually watch.

Prove: Ten people used it unprompted, and you can say what the second visit rate was.

Land the first paid piece of work (if your goal is free)

Learn: Scoping, pricing by outcome, and writing a proposal that survives a sceptical client.

Build: A one-page service offer built around the thing you have already shipped.

Prove: One signed piece of paid work, however small.

Design for uncertainty

Learn: What changes when output is probabilistic: loading states, wrong answers, confidence, and undo.

Build: A redesign of one AI feature you already use, fixing how it handles being wrong.

Prove: A before-and-after with a written note on each decision.

About 10 hours.

Prototype without waiting

Learn: Building working prototypes with AI rather than static mockups. Enough HTML to be dangerous.

Build: A clickable, functioning prototype of a real flow — not a Figma file.

Prove: Someone used it and you watched, without explaining anything first.

About 14 hours.

Make it usable by everyone

Learn: Screen readers, keyboard order, contrast, and how AI output breaks all three.

Build: An accessibility pass on your prototype, with the specific failures listed.

Prove: It works keyboard-only and with a screen reader, and you tested that yourself.

About 16 hours.

Test with real people

Learn: Running five-person tests, writing tasks not questions, and hearing what you did not want to hear.

Build: Five sessions on your prototype with the tasks written in advance.

Prove: A list of what broke, ranked, and what you changed as a result.

About 18 hours.

Design the system, not the screen

Learn: Patterns for AI interfaces: sources, confidence, correction, and the escape hatch.

Build: A small pattern library for how your product handles AI being unsure or wrong.

Prove: Another designer applied it to a screen you did not design.

About 20 hours.

Change how your team ships (if your goal is job)

Learn: Making the case internally, and getting a pattern adopted rather than admired.

Build: A working prototype that replaced a spec document in a real project.

Prove: A decision got made faster because of something you built.

Build the portfolio that gets read (if your goal is switch)

Learn: Case studies that show judgement, not just screens.

Build: Three pieces, each with the problem, the tests you ran, and what you changed.

Prove: A designer you respect gave you feedback on your reasoning, not your visuals.

Design something people keep using (if your goal is product)

Learn: Onboarding, first-run experience, and designing for the second visit.

Build: A live product with ten real users and instrumented drop-off.

Prove: You can name where people stop, and what you tried about it.

Land the first paid piece of work (if your goal is free)

Learn: Scoping design work, pricing, and proposals that survive a sceptical client.

Build: A service offer built around AI prototyping, with your own work as proof.

Prove: One signed piece of paid work.

Research at speed

Learn: Using AI for genuine research — and how to catch it when it invents a source.

Build: A competitor and audience analysis for a real business, every claim traced.

Prove: Every number in it has a link. You found at least one thing the AI got wrong.

About 10 hours.

Build a message system

Learn: Positioning, and how the same claim lands differently on different fears.

Build: A tool that rewrites one offer for three audiences and flags unsupported claims.

Prove: Someone in sales used a version of it in a real conversation.

About 14 hours.

Automate the repetitive part

Learn: Visual workflow tools, triggers, and where automation quietly goes wrong.

Build: One workflow that saves you two hours a week, with a human check on anything published.

Prove: It has run for two weeks without you fixing it.

About 16 hours.

Run a real experiment

Learn: Sample size, what a result means at small numbers, and honest measurement.

Build: One A/B test on something that matters, designed before you look at any data.

Prove: You wrote the hypothesis first, and you were willing to call it inconclusive.

About 18 hours.

Turn it into a system

Learn: Documenting a process so somebody else can run it without you.

Build: A playbook for the campaign work, with the prompts, the checks and the failure modes.

Prove: A colleague ran it end to end without asking you a question.

About 20 hours.

Change how your team works (if your goal is job)

Learn: Getting adoption, and measuring what actually improved.

Build: Your playbook running as the team default for one campaign type.

Prove: Two colleagues use it weekly, and you can show the time saved.

Build the portfolio that gets read (if your goal is switch)

Learn: Marketing case studies that show reasoning, not just results.

Build: Three write-ups: the problem, the experiment, the number, what you would do next.

Prove: One of them includes something that did not work, and what you learned.

Get a product its first hundred users (if your goal is product)

Learn: Channel testing, positioning under pressure, and knowing when to stop.

Build: A launch with three channels tested and one doubled down on.

Prove: A hundred real users, and you can say which channel earned them.

Land the first paid client (if your goal is free)

Learn: Packaging marketing work as an outcome, not hours.

Build: A one-page offer built on the playbook you already proved.

Prove: One signed client.

Research every account properly

Learn: Fast, honest account research — and never letting the AI invent a fact about a company.

Build: A prep tool that turns scraps into a one-page brief, marking every guess as a guess.

Prove: You used it before ten real calls, and it never stated something untrue.

About 10 hours.

Personalise without lying

Learn: What actually earns a reply, and why obvious automation reads worse than nothing.

Build: An outreach tool grounded in real research, that refuses to send when it has nothing specific.

Prove: A reply rate you measured before and after, on at least fifty sends.

About 14 hours.

Automate the admin

Learn: Workflow tools, and putting a human in front of anything that reaches a customer.

Build: Automatic call notes and follow-up drafts — with approval before anything sends.

Prove: It has run for two weeks and never sent something you would not have.

About 16 hours.

Connect it to the CRM

Learn: Integrations, data hygiene, and why a half-updated CRM is worse than an empty one.

Build: Notes and next steps written back automatically, with conflicts flagged not overwritten.

Prove: A week of deals where nobody typed a note by hand and nothing was lost.

About 18 hours.

Measure what changed

Learn: Attribution, honest baselines, and resisting the story you want to tell.

Build: A before-and-after on one metric, with the confounders written down.

Prove: You can say what improved, by how much, and what else might explain it.

About 18 hours.

Roll it out to the team (if your goal is job)

Learn: Training people who did not build it, and handling the one who refuses.

Build: Your workflow running for the whole team, with a one-page guide.

Prove: Everyone uses it, including the sceptic, and you can show the number.

Build the portfolio that gets read (if your goal is switch)

Learn: Showing sales-engineering judgement in a way a hiring manager can check.

Build: Three write-ups of tools you built, with the metrics and what failed.

Prove: One includes a tool you turned off, and why.

Turn it into a product (if your goal is product)

Learn: What makes an internal tool sellable, and what makes it not.

Build: A version another team could use without you configuring it.

Prove: A team outside yours used it for two weeks.

Land the first paid client (if your goal is free)

Learn: Selling sales-ops work on outcome, with your own numbers as proof.

Build: An offer built on the workflow you already measured.

Prove: One signed client.

Choose the right problem

Learn: Separating symptom from cause, and weighting by impact rather than by who complained loudest.

Build: A triage tool that turns raw complaints into ranked problems with evidence attached.

Prove: It found a problem your team had not named, traceable to specific tickets.

About 10 hours.

Design the workflow, not the feature

Learn: Where AI belongs in a process, and where it makes things quietly worse.

Build: A map of one workflow with the AI step, the human step, and the failure path marked.

Prove: Someone who works that process agreed the map was right.

About 14 hours.

Prototype it yourself

Learn: Enough building to test an idea without booking engineering time.

Build: A working prototype of the workflow, not a slide about it.

Prove: You put it in front of three users and changed it afterwards.

About 16 hours.

Decide how you will know

Learn: Evaluation for non-deterministic features, and what a fair baseline looks like.

Build: A test set and a success threshold, both written before the build starts.

Prove: You can state the number at which you would kill the feature.

About 18 hours.

Run a real pilot

Learn: Scoping a pilot so its result is believable, and pre-committing to the decision.

Build: A four-week pilot with real users, a control, and a written decision rule.

Prove: A go/no-go decision made on the evidence, including the option of no.

About 20 hours.

Ship it properly (if your goal is job)

Learn: Rollout, monitoring, and what to watch after launch.

Build: The feature live for everyone, with the metric on a dashboard.

Prove: Four weeks in production and you can say whether it worked.

Build the portfolio that gets read (if your goal is switch)

Learn: PM case studies that show decisions, not roadmaps.

Build: Three write-ups: the problem, the evidence, the decision, the outcome.

Prove: One documents a feature you decided not to build, and why.

Take it to market (if your goal is product)

Learn: Positioning, pricing, and the first hundred users.

Build: A launched product with instrumented activation.

Prove: A hundred users and a retention number you can defend.

Land the first paid client (if your goal is free)

Learn: Packaging product work as a fixed-scope engagement.

Build: A discovery-and-prototype offer built on your pilot method.

Prove: One signed client.

Map where it actually helps

Learn: Separating genuine opportunity from vendor noise, and where AI reliably does not pay.

Build: A map of your operation with the three highest-value candidates and the reasons.

Prove: You can argue for each one to a sceptical board member.

About 8 hours.

Do the numbers honestly

Learn: Total cost including maintenance, and the difference between saved time and saved money.

Build: A model of one opportunity with every assumption exposed and editable.

Prove: Changing one assumption visibly changes the answer, and you know which one matters.

About 12 hours.

Name the risks before you start

Learn: Data, regulatory and reputational exposure, and the failure that would be slow and quiet.

Build: A risk register with owners and a stop condition for each.

Prove: You have written down what would make you shut it off.

About 12 hours.

Prototype before you commit

Learn: Cheap tests that produce a real signal, and resisting the vendor demo.

Build: A working prototype of the highest-value candidate, built in days not quarters.

Prove: Real staff used it on real work for a week.

About 16 hours.

Roll out under control

Learn: Staged rollout, human approval on anything irreversible, and honest measurement.

Build: A pilot with one team, a control group, and a pre-written decision rule.

Prove: A decision made on evidence — and you were willing for it to be no.

About 18 hours.

Make it how the company works (if your goal is job)

Learn: Change management, and training people who did not choose this.

Build: The pilot extended to a second team, with a named owner.

Prove: It survived a quarter without you driving it.

Build the evidence that travels (if your goal is switch)

Learn: Documenting operational change so it means something outside your company.

Build: Three write-ups with the numbers, the risks and what you got wrong.

Prove: Someone outside your company found one useful.

Turn the capability into a product (if your goal is product)

Learn: What makes an internal advantage sellable, and what makes it a distraction.

Build: A version another company could buy, tested with one friendly customer.

Prove: One external organisation used it for a month.

Advise other companies (if your goal is free)

Learn: Packaging operational judgement as an engagement rather than an opinion.

Build: A diagnostic-and-roadmap offer built on what you did yourself.

Prove: One signed advisory client.