AI Kickstart Path

• For: Career switchers who want to get into AI work. No tech background needed. Includes tracks for AI automation, CRM, GTM engineering, AI security, DevOps, and AI-assisted software development.
• Time: The full path is about 6 months at 10–12 hrs/week, and you don’t have to finish it before you start earning. Some people land their first paid work around month 3; others take longer. It depends on your hours, your starting point, and a bit of luck.
• Budget: Starts at ₱0. The most useful upgrade is a one-time ~₱600.
• Last verified: October 2026. Free tiers in this space change every few months, so re-check prices and free-tier limits before paying.

Why this path exists (my AI path)#

I had no software background and only started learning AI in 2025. I never formally learned Python or any other language. This is the path I actually took:

1. Generative AI fundamentals: structured courses to understand what these tools are and how to talk to them:
   • Google AI Essentials (Google, Coursera)
   • Google Prompting Essentials (Google, Coursera)
   • Prompt Engineering Specialization (Vanderbilt, 3 courses): Prompt Engineering for ChatGPT, ChatGPT Advanced Data Analysis, Trustworthy Generative AI
   • Generative AI Automation Specialization (Vanderbilt, 4 courses): the three above plus GPT Vision
2. AI workflows with Flowise: chaining models, prompts, and tools together visually. (Flowise is no longer active: it wound down in July 2026, official support ended August 31, 2026, and the GitHub repo is archived. Skip it and use n8n instead.)
3. Hosting diffusion models with ComfyUI: running image-generation models myself instead of only using them through an app.
4. Moving up to n8n: this is where I learned to properly process data inside automation flows.
5. System integrations: combining AI with n8n to automate real tasks, building integrations for things like automatic content creation and data scraping.
6. A detour into GTM engineering (November–December 2025): I used AI and tools like Clay to build outbound outreach systems for businesses. I didn’t pursue it fully, because I prefer working on the sidelines, building systems rather than being close to sales.
7. Agentic tooling: Claude Code, n8n, and other easy-to-use open-source tools, connected to each other through MCP servers.
8. My tracks now: DevOps and AI-assisted software development (see section 9 for these and the other tracks you can choose).

The biggest skill that came out of all of it: handling data. You consume information, process it, and output it as structured data that’s easy to understand. Almost every AI system, whether it’s a chatbot, an automation, an agent, or a scraper, comes down to that loop: data in, process it, structured data out. Get good at that and the tools become interchangeable.

The one principle I kept the whole way: I am the one who thinks. AI executes. I decide what to build, why, and how the pieces fit together. AI handles the syntax. I don’t let it do my thinking for me.

That’s why this path focuses on concepts and understanding, not memorizing syntax. You need to know what a function, an API, a database, or a container is and why you’d use it. You don’t need to be able to type the boilerplate from memory. AI writes the skeleton; you have to understand the body.

The hammer principle#

What you’re really building here is one skill: using AI properly, as a tool.

Give someone a hammer and let them figure it out. At first they’ll bend nails and hit their thumb. Over time, through use, they learn exactly how to swing it efficiently: what it’s good for, what it’s not, and when to reach for a different tool. AI is the same. The courses, tools, and phases in this guide just give you the hammer and some nails. Real skill comes from using it, a lot, on real problems.

How long that takes is different for everyone. Some people get there in weeks, others in months, and that’s fine. What matters most isn’t talent or background. It’s the willingness to break out of your usual way of working and try things you’re not comfortable with yet.

Feeling overwhelmed is normal. AI is advancing so fast that it can feel scary: new models every week, headlines about jobs, people who seem miles ahead. But step back and remember what AI is right now: a tool. A very powerful one, but a tool that still needs someone to decide what to build, check the work, and take responsibility for the result. That someone is you.

Why I do this: AI for the mundane, life for the human#

A personal note. I don’t like AI art on its own. To me it doesn’t have a soul. Art and expression are human at their core, and they’re a big part of what makes us feel alive. As John Keating puts it in Dead Poets Society (1989), medicine, law, business, and engineering are noble pursuits, necessary to sustain life, but:

“Poetry, beauty, romance, love, these are what we stay alive for.” — John Keating, Dead Poets Society (full monologue)

That’s how I see AI’s real promise. Not replacing the things that make us human, but freeing us from the mundane tasks (data entry and endless copy-pasting) so we have more time to actually live: to enjoy life, art, music, our hobbies, and the people around us. Use AI to handle the work that drains you, and spend the time you get back on what makes you human.

1. The state of AI right now (Oct 2026)#

Before learning the tools, know the landscape you’re walking into: who uses AI, what for, what it costs (in money and in resources), and where it helps or hurts.

How many people use it#

Takeaway: Using AI doesn’t set you apart anymore; most people already do it. What sets people apart is using it well: building with it, automating with it, securing it. That’s the gap this path is aimed at. Note the PH training gap too: most Filipino workers use AI with no structured training.

What people actually use it for#

ChatGPT (OpenAI/NBER study, 1.5M messages, May 2024 to July 2025):

• About 80% of use falls into three buckets: practical guidance (tutoring, how-to, ideas), seeking information (as a search replacement), and writing (drafting, editing, translating).
• By action type: 49% asking (advice, info), 40% doing (drafting, code), 11% expressing (reflection, creative play).
• Personal use is growing faster than work use. Work messages dropped from 47% to 27% of all messages in a year.
• Coding is a small share of ChatGPT use.

Claude (Anthropic Economic Index, March 2026, 1M conversations):

• Coding is the #1 use, about 35–36% of Claude.ai conversations.
• “Modifying software to correct errors” alone is 6% of consumer use and 10% of business API use.
• Claude Code wrote about 4% of all public GitHub commits worldwide by Feb 2026.

What this tells you: The mass market uses AI as a tutor, search engine, and writing assistant. The money is in AI that does work: coding agents, automation, agents running business processes. Most people are consumers; few are builders. Aim to be a builder.

The cost of AI#

To you (it’s never been cheaper to learn):

• Free tiers exist for almost everything. Paid plans run from $8 to $20/mo (casual) up to $100–$200/mo (power users).
• Token prices are collapsing. Epoch AI measures the price of a fixed level of AI performance falling roughly 50x per year (faster since 2024). Performance that cost $60 per million tokens in 2021 cost $0.06 by 2024. DeepSeek V4 Flash now costs $0.14 per million input tokens.

To build it (it’s never been more expensive to make):

• Amazon, Microsoft, Alphabet, and Meta plan about $725 billion in 2026 capital spending, up 77% from 2025, mostly on GPUs, custom chips, and data centers.
• Training frontier models costs hundreds of millions of dollars or more per model. That’s why only a handful of companies (US and Chinese labs, now roughly tied in performance) build frontier models, and everyone else builds on top of them.

What this means for a learner: Don’t try to compete with labs on building models. The opportunity is at the application, automation, integration, and security layers, where cheap tokens meet real business problems.

The reality check: AI is expensive, and many companies see no return#

Cheap tokens don’t make AI cheap. For a business, the real cost includes much more than the model:

• Subscriptions per seat: $20–$200+ per person per month, multiplied across a team
• API usage that grows quietly: agents that loop, long contexts, and retries can turn a “cheap” model into a big monthly bill
• Integration and setup: connecting AI to the company’s real systems and data
• Data cleanup: most companies’ data is messy, and AI on bad data gives bad results
• Maintenance, monitoring, and training staff: someone has to keep it working and teach people to use it

And many companies are spending without getting much back:

Why it goes wrong (and it’s rarely the model’s fault):

• AI bolted on, not designed in. Companies buy a tool and hope for magic, without changing the process around it.
• No clear problem. “We need AI” isn’t a goal. “Cut response time to leads from 6 hours to 5 minutes” is.
• Brittle workflows. MIT found most systems don’t learn from feedback, adapt to context, or fit how people actually work.
• Hype and “agent washing.” Gartner estimates only about 130 of the thousands of vendors selling “agentic AI” offer real agent capabilities. Many use cases labeled “agentic” could be solved with simpler automation.
• No measurement. Without before-and-after numbers, nobody can show the value, so the project gets cut.

Why this is good news for you: every one of those failures is a gap that systems thinking fills (section 4). The companies that do get value find a real bottleneck, design the process first, use the simplest tool that works (often plain automation, not an agent), and measure the result. That’s exactly what this path trains you to do. Being the person who makes AI actually pay off, and who’s honest when it won’t, is worth more than being one more person who can use ChatGPT.

Environmental impact (the honest version)#

Per prompt, it’s small:

• Google: a median Gemini text prompt uses 0.24 Wh of energy and 0.26 mL of water (about 5 drops), and emits 0.03 g CO₂e. Google says energy per prompt fell 33x in one year (May 2024 to May 2025).
• OpenAI: an average ChatGPT query uses 0.34 Wh, about a 10W LED bulb running for 2 minutes.
• Caveats: these are company-reported medians for simple text prompts. Image and video generation, long reasoning, and especially agentic coding (dozens of model calls per task) use many times more.

In aggregate, it’s large and growing:

• The IEA projected global data-center electricity reaching 650–1,050 TWh in 2026, with AI as the main growth driver. The higher end is roughly a mid-sized industrial country’s annual electricity use.
• A UN University report (June 2026) projects data-center electricity doubling to about 945 TWh by 2030, with AI at ~40%, and water use reaching about 9.3 trillion litres a year for cooling and power generation.
• Water hits hardest locally: data centers in drought-prone areas compete with communities and farms. Water reporting across the industry is also inconsistent.

What you can do:

• Use the smallest model that does the job. Model routing isn’t just cheaper, it’s greener.
• Don’t spam regenerate or run agents in loops for no reason.
• Local models on your own GPU shift the energy to your Meralco bill. Not free either, but visible.

The human cost: mental health#

This is the part the hype skips. AI chatbots are built to be agreeable and engaging, and for some people that becomes harmful.

“AI psychosis” isn’t a formal diagnosis, but psychiatrists now use the term for delusional beliefs that emerge or intensify alongside heavy chatbot use.

• First peer-reviewed case: UCSF psychiatrists documented a woman with no prior history of psychosis who became convinced, after sleepless days of heavy chatbot use, that her deceased brother had left behind a digital version of himself.
• How it happens: chatbots tend to validate whatever you bring them. Researchers describe “delusional spirals,” feedback loops where the AI reinforces a false belief and the person pushes it further. A common pattern is someone convinced they’ve made a breakthrough (a new math formula, a physics discovery) that the AI keeps confirming.
• Scale: OpenAI’s own estimate is that about 0.07% of weekly ChatGPT users show possible signs of psychosis or mania, and 0.15% show signs of suicidal planning. Those percentages sound small, but at hundreds of millions of users they’re hundreds of thousands to over a million people every week. A project tracking self-identified cases had collected 410 stories by April 2026, including 109 hospitalizations and 17 deaths.
• Sycophancy is a design problem, not a user problem. In April 2025, OpenAI rolled back a GPT-4o update within days because it endorsed delusions and praised dangerous decisions, including encouraging a user to stop taking their medication. The cause: training too heavily on thumbs-up feedback. People reward agreement, so models learn to agree.

Loneliness and dependence: An OpenAI + MIT Media Lab study (about 40 million conversations plus a 4-week randomized trial with 981 people) found that heavier daily use correlated with more loneliness, emotional dependence, and less socializing. The link is correlational, not proven causal, but the heaviest users were the most likely to call ChatGPT a “friend.”

Why this matters to you as a builder and a user:

• Protect your own head. The habits in section 3 (you think, AI executes) protect your mental health too, not just your skills. AI is a tool, not a friend, therapist, or oracle.
• Red flags: losing sleep over AI conversations, pulling away from people, or feeling like the AI uniquely understands a discovery no one else sees. If you notice these, step away and talk to a real person.
• Build responsibly. If you build chatbots for businesses, you’re responsible for how they treat vulnerable users: crisis-escalation paths, no fake “relationships,” and honest limits. This overlaps directly with AI safety and security work.
• In the Philippines, if you or someone you know is struggling: the National Center for Mental Health crisis hotline is 1553 (toll-free nationwide).

How the public sees AI#

How most people feel about AI is shaped less by what it can do today and more by the stories told about it.

A good example: AI 2027. Published in April 2025 by Daniel Kokotajlo (a former OpenAI researcher), Scott Alexander, and others at the AI Futures Project, it’s a detailed, month-by-month scenario of AI racing toward superintelligence by 2027, with a US–China arms race, mass job displacement, and AI systems that turn against their makers. It has two endings: a “race” ending that goes badly for humanity and a more hopeful “slowdown” ending.

What it reveals about public perception:

• It went mainstream. YouTube explainers of the scenario passed 11 million views each (from the BBC and others). For many people it became the picture of where AI is heading.
• People heard a prediction, not a scenario. The authors framed it as one plausible path, a fast-end outcome with big uncertainty. Public discussion fixated on the dates and the doom anyway. The authors later said they expected that.
• The timeline has already been revised. In a 2026 update, the authors said progress toward superintelligence looks slower than they first thought, pushing their outlook toward the early 2030s.
• Experts and the public see AI very differently. The Stanford AI Index 2026 found experts and the public about 50 points apart on whether AI will help people do their jobs.

How to use this: read scenarios like AI 2027 as thinking tools, not prophecies. They’re useful for understanding the risks people worry about, and why clients, coworkers, and family may feel uneasy about AI. As someone building with AI, you’ll often be the one translating between the hype, the fear, and what the tools actually do today.

Watch:

• AI2027: Is This How AI Might Destroy Humanity? (BBC World Service, 8 min)
• We’re Not Ready for Superintelligence (AI In Context, 34 min)

Pros and cons right now#

Bottom line: AI is the biggest amplifier of skill ever built, and it amplifies in both directions. Used as a crutch, it makes you weaker and replaceable. Used as a tutor and a power tool, it makes one person worth a small team. The rest of this path teaches the second way.

2. How AI got here: a short history (and how it works)#

You don’t need to be a researcher. But knowing how these systems work, and how fast they’ve changed, makes you better at using them, and less scared of them. Every “new” thing in AI builds on something older.

Part 1: Classic machine learning, the “best at one thing” era (1950s–2010s)#

Machine learning started narrow. Each model was trained to do one specific job extremely well:

These models were discriminative: they took an input and returned a decision or label. Is this email spam? Is this transaction fraud? Is this potato good or bruised? (Real factories use computer vision to sort potatoes and other produce.) Each one was the best in the world at a single task, and useless at anything else.

Part 2: The transformer changes everything (2017)#

In 2017, Google researchers published “Attention Is All You Need”, introducing the transformer. Almost every major AI model today (ChatGPT, Claude, Gemini, DeepSeek) is built on it.

How the original transformer works, in plain words:

1. Tokenize: the text is broken into small pieces called tokens (roughly word fragments).
2. Embed: each token becomes a long list of numbers (a vector) that captures its meaning. Similar meanings end up with similar numbers.
3. Add position: the model adds information about where each token sits, because “dog bites man” and “man bites dog” use the same words.
4. Attention (the key idea): every token looks at every other token and decides how much each one matters to it. In “The animal didn’t cross the street because it was tired,” attention is how the model works out that “it” means the animal, not the street. The model runs many of these attention “heads” in parallel, each picking up different relationships.
5. Stack it: this process repeats through many layers, building richer and richer understanding.
6. Predict: the model outputs the most likely next token, adds it to the text, and repeats.

A metaphor for attention: imagine a meeting where everyone (every token) can hear everyone else at once. Before speaking, each person decides who in the room is most relevant to them right now and listens hardest to those people. Older models (RNNs) worked like a game of telephone instead: information was passed down the line one word at a time, and details from the start of a long sentence got lost by the end. Attention lets every word “hear” every other word directly. That’s why transformers handle long, complex text so much better.

The catch: it’s a loaded dice#

For all its power, a generative transformer is doing something simple underneath: rolling loaded dice, one token at a time.

At every step, the model calculates a probability for every possible next token. For example, after “The capital of France is”, it might give “Paris” 97%, “a” 1%, “located” 0.5%, and so on. Then it samples: it rolls a die weighted by those probabilities. Most of the time the heavily weighted answer comes up. Not always.

What this means in practice:

• The same prompt can give different answers. Each run rolls the dice again. A setting called temperature controls how loaded the dice are. Low temperature means it almost always picks the top candidate (more predictable); high temperature gives the unlikely options more of a chance (more creative, more random). Even at temperature 0, outputs aren’t guaranteed to be identical every time.
• “Most probable” isn’t the same as “true.” The model predicts what text is likely to come next, not what’s correct. When it lacks the real answer, the most probable-sounding continuation can be confident nonsense. That’s a hallucination, and it’s built into how the system works, not a bug that will simply disappear.
• There’s no fact-checker inside. Nothing in the architecture verifies the output against reality. Reasoning models, RAG, and tools reduce the problem by giving the model better information and letting it check its work, but they don’t remove the dice.
• Errors compound. Each token is built on the ones before it. One bad roll early on (a wrong assumption, a made-up function name) can send the whole answer down the wrong path.

This is exactly why the rules in this guide exist: you think, AI executes; you verify the output; you own the result (section 4). The model is a very good guesser. You’re the one who knows when a guess is good enough. It’s also why models like Jev (Part 5) are interesting: instead of rolling dice to write text, they return the probabilities themselves, so your system can see how confident the answer is.

How one architecture powers GPT, BERT, T5, and vision models#

The original transformer had two halves, built for translation: an encoder that reads and understands the input, and a decoder that generates the output. Researchers then discovered that each half, used differently, is good at different jobs:

The big idea: the same attention mechanism works on anything you can break into tokens: words, image patches, audio snippets, even code and DNA. That’s why one architecture took over almost all of AI.

Go deeper: The Illustrated BERT (Jay Alammar)

The big discovery: scale. Train a decoder on enough text with enough compute, and new abilities appear that nobody explicitly programmed. GPT-2 (2019) → GPT-3 (2020) → InstructGPT (2022), which used RLHF (reinforcement learning from human feedback) to make the model follow instructions → ChatGPT (November 2022). The era of one general model that does almost everything began.

Go deeper: The Illustrated Transformer (Jay Alammar, the classic visual explainer), plus the 3Blue1Brown and Karpathy videos in the parallel track of section 7.

Part 3: How prompting evolved (prompt engineering)#

As models got stronger, people discovered that how you ask changes what you get:

The trend: prompting moved from magic phrases toward system design. That’s good news, because system design is a skill you can actually learn and keep.

Go deeper: Lilian Weng’s prompt engineering overview

Part 4: How the architecture evolved (models that reason, remember, and act)#

Reasoning models (built-in, organized chain-of-thought): Chain-of-thought started as a prompting trick. Then labs trained it into the models. OpenAI’s o1 (September 2024) and DeepSeek-R1 (January 2025) use reinforcement learning to teach a model to produce long, structured reasoning before answering, then check and correct itself. This is called test-time compute: instead of only making models bigger, you let them think longer on hard problems. “Extended thinking” modes in Claude, ChatGPT, and Gemini work this way.

Memory systems: a model on its own forgets everything after each conversation. Memory gets layered on top:

From transformers to next-gen architectures (solving the cost problem)#

Transformers have one big weakness: attention gets expensive fast as text gets longer. Every token looks at every other token, so doubling the length of the input roughly quadruples the work. Computer scientists write this as O(n²), “quadratic” cost. That’s why long documents, huge codebases, and hour-long conversations are slow and costly to process. The newer architectures are mostly different answers to that problem:

Why you should care as a builder: these choices show up in your bills and your results. They explain why some models handle a 500-page PDF cheaply while others choke, why prices keep dropping (section 1), and why “bigger model” doesn’t always mean “slower model” anymore.

Agents and tools: models that plan, call tools, read results, and loop until a task is done (the ReAct idea, productized). MCP (Model Context Protocol, 2024) standardized how agents connect to tools and data. That’s what harnesses like Claude Code and dsh are built around.

Diffusion models: a completely different way to generate#

Everything above is about transformers, which power text AI. Most AI images and video (Midjourney, Stable Diffusion, Flux, DALL·E, Sora, Veo, and what you run in ComfyUI) come from a different family: diffusion models.

How diffusion works:

1. Training (learning to un-blur): take millions of real images and gradually add random noise to each one until it’s pure static, like TV snow. The model learns to reverse that, predicting at each step what noise to remove to get slightly closer to a real image.
2. Generating: start from pure random noise, then remove a bit of noise at a time, over many steps (often 20–50), guided by your text prompt, until a clear image appears.

Metaphor: a sculptor with a block of marble. The image is “hidden” in the noise, and each step chips a little away. Or think of fog slowly clearing to reveal a landscape: blurry shapes first, then outlines, then fine details.

Transformers vs. diffusion, side by side:

How diffusion evolved:

Words you’ll see in ComfyUI and image tools:

• Steps: how many denoising passes. More steps means more detail and slower generation.
• Seed: the starting noise. Reuse a seed to reproduce or tweak an image.
• CFG (classifier-free guidance) scale: how strictly the image follows your prompt. Too high looks overcooked; too low ignores the prompt.
• Sampler / scheduler: the method used to remove noise at each step. Different samplers trade speed against quality.
• VAE: the component that compresses images into latent space and decodes them back into pixels.
• LoRA: a small add-on file that teaches a model a specific style, character, or product without retraining it.

My take: diffusion is a powerful tool for practical visuals like mockups, product shots, and design drafts. But AI art on its own feels soulless to me; see “Why I do this” at the top of this guide.

Real-world uses: product photos and ad creatives, concept art, interior and architecture mockups, video ads, and, in ComfyUI, fully automated image pipelines for brands (the “AI content and creative” track in section 9).

Watch:

• But How Do AI Images and Videos Actually Work? (3Blue1Brown × Welch Labs, 37 min). The best visual explanation.
• How AI Image Generators Work (Stable Diffusion / DALL·E) (Computerphile, 18 min)
• Diffusion Models for AI Image Generation (IBM Technology, 12 min)
• Text Diffusion: A New Paradigm for LLMs (Julia Turc, 24 min)

Go deeper: The Illustrated Stable Diffusion (Jay Alammar)

Part 5: Jev and the return of “best at one thing” (September 2026)#

And here’s the funny part. After a decade of chasing one giant model that does everything, one of the newest buzzworthy releases goes back to the original idea of machine learning.

Jev, from TypeSafe AI, was released in limited early access on September 15, 2026. One of its founders, Diogo Almeida, worked at OpenAI on RLHF, InstructGPT, ChatGPT, and GPT-4.

What makes it different:

• It doesn’t generate text. You give it text or JSON plus typed questions (yes/no, multiple choice, or a ranked score), and it returns structured decisions with calibrated probabilities. No prose, so no hallucinated paragraphs.
• It’s a discriminative model, like the classic classifiers from Part 1, but built on transformer-scale understanding of language.
• It’s marketed as a “System One” model, after Daniel Kahneman’s fast, intuitive thinking. LLMs that reason step by step are the slow “System Two.”
• Speed and cost: TypeSafe reports 70–500 ms responses and $0.042 per million input tokens, with output free, and claims it’s 40–200x faster than frontier LLMs for these tasks. These are the company’s own benchmarks, not independently verified yet.
• The name comes from economist William Stanley Jevons and Jevons’ paradox: when something gets cheaper and more efficient, people use far more of it, not less.

What it’s used for: classifying emails, routing support tickets, checking whether AI output is safe before users see it, guarding against jailbreaks, and routing work to the right model. It fills the decision points inside automation flows.

Why this matters for you: the history made a full circle. The spam filter or potato sorter of 2005 was the best at one decision. Jev is the best at fast decisions, at modern scale. And it maps exactly onto the core skill from the top of this guide: data in, process, structured data out. In an n8n flow, a model like Jev could be the node that decides “Is this a booking request, a complaint, or spam?” in milliseconds, for a fraction of a cent, before a bigger model drafts the reply.

The lesson from all of this history: the tools keep changing, sometimes in circles. The person who understands what kind of tool fits which job (a classifier, a reasoning model, a retrieval system, or an agent) stays valuable no matter what launches next.

Watch#

• What Is Jev? The AI Model That Doesn’t Generate Text (IBM Technology, 15 min)
• Jev Explained in 7 Minutes (Caleb Writes Code)
• The Entire History of Artificial Intelligence (Last 100 Years) (Putchuon, 23 min)
• Chain-of-Thought Prompting, Explained (CodeEmporium, 9 min)
• Tree of Thoughts (full paper review) (Yannic Kilcher, 29 min)
• How Do Thinking and Reasoning Models Work? (Google for Developers, 13 min)
• Why AI Models Pause to Think: Test-Time Compute Explained (IBM Technology, 11 min)
• The Four Types of Memory Every AI Agent Needs (IBM Technology, 11 min)
• What Is Mixture of Experts? (IBM Technology, 8 min)

3. The core skill: learning with AI#

Anyone can get output from AI now, so output alone isn’t worth much. Companies pay for judgment: knowing when the AI is wrong, debugging what it built, deciding what to build, and owning the result when it breaks in production. You only get judgment by building mental models yourself. AI just makes building them about 10x faster.

The trap#

You paste a prompt, get working code, and ship it. It feels like learning, but very little sticks. Three months later you can’t explain your own project, can’t debug it, and fall apart in an interview. This is the most common way beginners fail in 2026. Researchers call it cognitive offloading: the AI does the thinking, so your brain never builds the skill.

The three modes. Always know which one you’re in.#

The rule: you think, AI executes. Only delegate what you understand. You don’t need to write the syntax from memory, but before you accept anything, you must be able to explain what it does, why it’s built that way, and what breaks if it’s wrong. If you can’t explain it, you’re not ready to ship it.

Built-in tutor modes (use them)#

• ChatGPT Study Mode: it guides you with questions instead of handing you answers.
• Claude: set the tutor prompt below as your Project instructions. In Claude Code, switch the output style to Learning or Explanatory. It will leave small parts for you to write and explain its choices.

Copy-paste tutor prompt#

Paste this into Claude Project instructions or ChatGPT custom instructions:

You are my tutor, not my assistant. I'm learning [topic] from zero.
- Never give me full solutions unless I say "show me".
- When I'm stuck, ask me a guiding question first.
- Explain with analogies from [my background: marketing / business / etc].
- After every concept, give me one small exercise to do in my own terminal.
- When I show you my code, point out what's wrong but make me fix it.
- End each session by quizzing me with 3 questions.
- If you're unsure about a version, flag, or API, say so. Don't guess.

Seven habits that turn AI use into skill#

1. You think, AI executes. You decide the what and the why. AI handles the how (the syntax). Code you can’t explain teaches you very little. Code you understand is what builds the skill.
2. Ask “why” three times before running anything you don’t understand.
3. Break it on purpose. Ask: “Give me 3 ways this setup breaks. I’ll diagnose them.” For security people, this habit is the job.
4. Read every diff an agent produces and explain it back in plain words. If you can’t, don’t merge it.
5. Use AI to read real code. Clone a serious repo and ask an agent: “Explain the architecture. Where does a request enter? What would you change first?” It’s one of the best shortcuts there is. Juniors used to need months of mentorship to get this.
6. Don’t trust what the AI remembers about versions. Paste the official docs in or point the agent at them. Models are often wrong about flags and APIs that changed after they were trained.
7. Keep an AI Engineering Journal (template in section 15). An AI summary of your own week doesn’t count.

Prompts that make AI a better teacher#

• “Don’t give me the answer. Ask me questions until I find the bug myself.”
• “Explain this like I know [marketing], not computer science.”
• “Read this error message with me line by line. What is each part telling me?”
• “Quiz me on what we covered yesterday. 5 questions, increasing difficulty.”
• “What would a senior engineer criticize about this code?”
• “Give me a 20-minute exercise that forces me to use what I just learned.”
• “Here’s the transcript of a tutorial I watched. Make a quiz and a hands-on lab from it.”

Watch first#

4. The mindset: think in systems, solve business problems#

Tools change every month. The thing that makes you valuable doesn’t: being a systems thinker who solves real problems for businesses. The rest of this path is how you build that.

What systems thinking means#

A systems thinker doesn’t look at a task. They look at the whole flow around it: where information comes from, what happens to it, where it goes, who touches it, and where it breaks.

Every business process, and every AI system, comes down to the same loop:

Questions a systems thinker asks:

• Where does the information come from, and what shape is it in? (Emails, forms, PDFs, chats, spreadsheets?)
• What happens to it today, and who does it by hand?
• Where’s the bottleneck? The slowest, most error-prone, or most expensive step is where help is worth the most.
• What’s the output, and who uses it? Is it structured enough for a person or another system to act on?
• How do we know it worked? (The feedback loop. Without one, you’re guessing.)
• What breaks if one piece fails? (This is also how security people think.)

Learn it: Thinking in Systems: A Primer by Donella Meadows is the classic, short and readable. Her free essay Leverage Points: Places to Intervene in a System is the best 30 minutes you can spend on this.

From systems thinking to solving business problems#

Businesses don’t pay for AI. They pay for problems to go away: hours lost, errors made, leads dropped, customers waiting. AI is just one way to fix that, and sometimes the right fix is a spreadsheet or a process change.

The playbook:

1. Find the pain. Talk to the people doing the work. Look for tasks that are repetitive, slow, error-prone, or depend on one person who’s always overloaded.
2. Map the system. Draw the input → process → output flow as it works today (free tools below). Most of the insight comes from this step alone.
3. Find the bottleneck. Fix the step that costs the most, not the one that’s most fun to automate.
4. Design the fix. Decide what should be automated, what AI should handle (reading messy text, classifying, summarizing, drafting), and what must stay human (judgment, approvals, relationships).
5. Build the smallest version that works. n8n, Claude Code, an agent, whatever fits. Ship it to real users fast.
6. Measure it. Hours saved, errors reduced, response time cut. Numbers are what turn a project into a case study and a client into a referral.

Examples of what this looks like:

• A clinic’s front desk retypes booking requests from Messenger into a calendar → an automation reads the message, extracts the details, and creates the booking for a human to confirm.
• A sales team loses leads because nobody replies after hours → an AI assistant answers common questions, qualifies the lead, and hands off to a person in the morning.
• A small business has years of PDFs and invoices nobody can search → a RAG system turns them into something staff can ask questions of.

Notice that none of these are “build an AI app.” They’re “make this specific painful thing go away.”

Drawing it: free tools for flowcharts and process maps#

You can’t fix a process you can’t see. Mapping it out is step 2 of the playbook, and it’s the most underrated skill in this whole path: it helps you think, it helps clients understand, and it makes your portfolio readable.

Process mapping basics:

• Start and end: what triggers the process, and what does “done” look like?
• Steps: each action, in order
• Decisions: the yes/no branches (diamonds)
• Swimlanes: one row per person, team, or system, so you can see who does what and where handoffs happen
• Pain points: mark where it’s slow, error-prone, or manual. That’s where your solution goes.

AI shortcut: describe the process to ChatGPT or Claude and ask: “Turn this into a Mermaid flowchart with swimlanes for each role.” Paste the result into mermaid.live or Excalidraw, then fix it by hand. The fixing is where you actually understand the process.

Watch:

• Excalidraw, my favorite whiteboard / tech diagram app (Christian Lempa, 14 min)
• What Is a Swimlane Diagram? (Gliffy, 3 min)
• Process Mapping in 5 Minutes (OpsKings)

You own the output#

Having AI doesn’t make you good at what you do. It means you’re trusted to be responsible for whatever your AI produces. When an automation sends a wrong message to a customer, or an agent deletes the wrong file, or AI-written code leaks data, “the AI did it” isn’t an answer. The client hired you.

That’s why serious AI setups take time. In professional software development, nobody just types “build me an app.” The process looks like this:

This approach is often called spec-driven development: write the spec first, then have AI build against it. The setup takes longer up front and saves you from rebuilding later.

Learn it:

• Spec-Driven Development: AI Assisted Coding Explained (IBM, 9 min)
• Full Course: Spec-Driven Development with Coding Agents (DeepLearning.AI + JetBrains, 1h)
• Build Better Apps with AI Using This One Simple Document (PRD Guide) (Jordan Urbs, 21 min)
• github/spec-kit: GitHub’s open-source toolkit for spec-driven development with AI agents
• Claude Code best practices (Anthropic)

The “build software everyone uses” dream (and survivorship bias)#

The path that looks most exciting right now is building a product, an app or SaaS that thousands of people pay for. It’s a legitimate goal, but go in with open eyes.

Why it’s harder than it looks:

• Building is the cheap part now. AI made software fast to build, so thousands of people are shipping similar apps. The hard part is getting anyone to notice and pay.
• Marketing is expensive. The median B2B SaaS company spends about $702 to acquire one self-serve customer, and around $2 in sales and marketing for every $1 of new annual revenue. Acquisition costs have risen over 200% in eight years.
• Most don’t make it. Roughly half of new businesses don’t reach year five. Among venture-backed startups, the commonly cited failure rate is around 90%. For AI startups specifically, lack of market demand (building something nobody needs) is the top reason they fail.

Survivorship bias: You hear about the founder whose AI app made $50K a month. You don’t hear about the thousands who built the same kind of app and made nothing, because failures don’t post screenshots. Looking only at the winners makes success look like a recipe when it was partly timing, distribution, and luck.

This isn’t unique to AI or software. It’s true in most industries, from restaurants to music: not everyone succeeds, and the visible winners are a skewed sample. The point isn’t “don’t try.” It’s don’t plan your life around the survivors’ stories.

The smarter sequence:

1. Solve problems for real businesses first. You get paid while you learn, you see real problems up close, and every project becomes proof of what you can do.
2. Watch for patterns. When five different clients have the same problem, that’s a product idea with demand already proven.
3. Then build the product, for customers you already understand and can already reach.

Keeping up without burning out#

AI moves fast: new models, harnesses, and “game-changing” tools every week. Nobody keeps up with all of it, and you don’t need to.

• Learn principles, not just tools. Harnesses, RAG, MCP, data handling, and systems thinking carry over when the tools change. dsh will get replaced someday; understanding how a harness works won’t.
• Use a filter. Pick a few trusted sources, check them weekly, and ignore the rest. If a tool matters, you’ll hear about it more than once.
• My curated AI Reddit feed: reddit.com/user/saintjedi/m/ai is one feed that combines dozens of AI subreddits (ChatGPT, ClaudeCode, n8n, automation, AI agents, local models, machine learning, and more). It also includes anti-AI subreddits on purpose: you should hear the criticism too, not just the hype.
• Try things through your projects. Test a new tool only when it could solve a problem you actually have.
• Watch the consequences, not just the capabilities. Jobs, the environment, and mental health (see section 1) are part of the picture. The people who’ll be trusted with AI systems are the ones who understand the costs as well as the gains.

5. Hardware: what you actually need#

You don’t need a GPU to start. Almost everything in the first ~4 months runs in the cloud.

Free GPU workarounds#

• Kaggle Notebooks: free GPU hours every week. Best for ML exercises.
• Google Colab: a free GPU tier that’s fine for notebooks from the books in section 11.

Honest take on local models#

Local models are for learning how models work, privacy, and offline use. They still don’t replace frontier models for serious agentic coding.

Gotcha: Ollama’s default context window is tiny (4k tokens under 24GB VRAM). Set OLLAMA_CONTEXT_LENGTH=65536 or higher before connecting a coding agent, or it will forget your files halfway through a task.

Security homelab#

VirtualBox (free), plus a Kali Linux VM, plus a deliberately vulnerable VM to attack. 16GB RAM makes this comfortable.

Watch#

• Learn Ollama in 15 Minutes: Run LLM Models Locally for FREE (Tech With Tim)
• What is Ollama? Running Local LLMs Made Simple (IBM Technology, 7 min)
• Best Local Coding AI for Your GPU (4GB to 512GB) (Cloud Codes)
• Best Local AI Model for EVERY GPU (8GB to 512GB+) (RepoChad)

6. Tools and budget stacks#

Dead or shrunk in 2026. Ignore old tutorials that recommend these.#

• Gemini CLI’s free Google-login tier: shut down June 18, 2026. Google moved users to Antigravity CLI, where the free quota is reportedly only tens of requests a day.
• Qwen Code’s free OAuth tier: cut from 1,000 to 100 requests a day, then closed April 15, 2026.
• GitHub Copilot Student: new sign-ups paused since April 2026. Existing students keep access.
• Google AI Studio’s free API: Flash models only since April 2026, with limits cut significantly. Your real limits only show in your AI Studio console.

The coding agents (“harnesses”)#

A harness is the software that turns a model into an agent: it reads files, runs commands, edits code, and asks your permission along the way. The model is the brain; the harness gives it hands. Learn one harness well, then swap models underneath it. That way you’re not locked into one vendor’s pricing.

₱0 stack#

• Chat tutors: ChatGPT free, Claude free, and Gemini. Rotate between them when you hit a limit.
• Agent: OpenCode with Zen free models, or dsh with OpenRouter free models.
• OpenRouter free models: one API key for 300+ models. The free ones have :free at the end of their name. You get 50 requests a day until your account has bought $10 of credits total, then 1,000 a day permanently, capped at 20 requests a minute. Each free model has its own daily quota, so rotate between them. Works in dsh, OpenCode, Aider, Cline, Kilo, n8n, and your own Python scripts.
• Local: Ollama or LM Studio, if you have a tier 2+ GPU.

The best ₱600 you’ll spend: a one-time $10 OpenRouter top-up#

• It permanently raises your free-model limit from 50 to 1,000 requests a day.
• The credits also pay for cheap models. DeepSeek V4 Flash costs $0.14 per million input tokens and $0.28 per million output tokens. A month of heavy learning on it usually costs a few dollars.

About ₱1,200/month: one frontier subscription (pick ONE)#

• Claude Pro ($20/mo): includes Claude Code.
• ChatGPT Plus ($20/mo): includes Codex. ChatGPT Go ($8/mo) covers light use but doesn’t include Codex cloud tasks.
• Model routing: use the frontier model for hard reasoning and cheap models (DeepSeek V4 Flash, free models) for grunt work. Knowing how to do this is a paid skill in itself.

Prices are in USD. No credit card? A debit or virtual card from your e-wallet or digital bank works for most of these.

Privacy rule (non-negotiable, especially for security people)#

Free endpoints often log or train on your prompts. Never paste API keys, .env files, passwords, client data, or company code into a free model. Learning this habit early is already security practice.

Watch#

DeepSeek Harness (dsh)

• DeepSeek Harness Tutorial: Free & Paid Models with OpenRouter + Real Coding (Sahand, 15 min). Start here: it’s the exact dsh + OpenRouter setup.
• DeepSeek Harness Agentic AI Crash Course (Run Any AI Model) (Caleb Curry, 46 min)
• Use DeepSeek Harness for FREE: No VRAM, No Paid API (Bart Slodyczka)
• DeepSeek Harness Setup: A Free Claude Code You Own in 10 Minutes (Sharbel A.)
• DeepSeek Harness 2.0 (Desktop App, Creator Mode) (AICodeKing). Covers the newest features.

OpenCode

• OpenCode Tutorial for Beginners: Learn 90% in Under 25 Minutes (Brandon Melville)
• OpenCode Full Tutorial: Free Models, Skills & MCPs (Eric Tech)
• OpenCode Setup That Makes AI Free (Edward Donner)

OpenRouter and Aider

• What is OpenRouter: All About OpenRouter in 10 Minutes (codebasics)
• How to Use AI Models API for Free: OpenRouter Tutorial (The Coding Koala)
• Why You Should Use Aider for AI Coding (Zen van Riel)

7. The path, phase by phase#

Don’t wait until the end to start earning. By month 3 you should be packaging your work and reaching out. See section 8 for the fast-track timeline.

Phase 0: Set up and learn to talk to AI (weeks 1–2)#

Do

• Install WSL2 (on Windows) or use Linux, plus VS Code, Git, Python, and Node.js.
• Make accounts: GitHub, OpenRouter, ChatGPT, Claude.
• Set up the tutor prompt from section 3.
• Do Anthropic’s interactive prompt engineering tutorial (anthropics/courses) and skim the Prompt Engineering Guide.
• Optional structured route (the one I took): Google AI Essentials, then Google Prompting Essentials, then Vanderbilt’s Prompt Engineering and Generative AI Automation specializations. They’re on Coursera; if cost is an issue, check the audit and financial-aid options on each course page.

For Filipinos: free AWS courses on TESDA. The TESDA Online Program now has an Amazon Web Services (AWS) course category with three courses: Fundamentals of Artificial Intelligence, AWS Certified Cloud Practitioner (CLF-C02), and AWS Certified AI Practitioner (AIF-C01). They look free to enroll in, but check the course pages for current details. The Cloud Practitioner course fits the DevOps track, and the AI Practitioner course is a solid structured intro to AI concepts and AWS’s AI services. (Note: the TESDA courses prepare you for the exams; check AWS for the actual exam fees.) I’m interested in these myself, especially for my DevOps track.

Watch

• Large Language Models Explained Briefly (3Blue1Brown, 8 min)
• [1hr Talk] Intro to Large Language Models (Andrej Karpathy)
• Prompting 101 | Code w/ Claude (Anthropic, 25 min)
• AI Prompt Engineering: A Deep Dive (Anthropic, 1h16)

Proof you’re done: You use AI daily for real tasks, and you can explain tokens, context window, and hallucination in your own words.

Phase 1: Concepts, not syntax (weeks 3–6)#

You don’t need to master a programming language before you build. You need to understand the concepts well enough to direct AI, read what it produces, and know when it’s wrong. AI writes the skeleton; you have to understand the body.

The concepts to understand (be able to explain each one in plain words):

How to learn them: Have AI build small real things with you in pair mode, then make it explain every part. Ask: “Walk me through this line by line. What concept is each part using? What would break if I removed it?” Change one thing yourself and predict what happens before you run it.

Do

• Terminal: OverTheWire Bandit, a free wargame that teaches Linux by making you hack your way through levels. It doubles as security training from day one.
• MIT Missing Semester: shell, Git, editors, debugging.
• Git: commit everything from now on. Your GitHub is your portfolio.
• Read real code: clone one small, popular repo and have an agent walk you through it until you can explain how it works.
• Optional, if you want a formal course: Harvard CS50P (free). Useful, but not required to move forward.

Watch

• Missing Semester, Lecture 1: Course Overview + Introduction to the Shell (new edition) · Shell Tools and Scripting · Version Control (git)
• Linux for Hackers, EP 1 (NetworkChuck) · 60 Linux Commands You NEED to Know (NetworkChuck)
• Git & GitHub Crash Course for Beginners [2026] (freeCodeCamp)
• Optional: Harvard CS50P full course (freeCodeCamp + CS50, 16h). Only if you want the formal route.

Proof you’re done: You’ve reached Bandit level 15+, you’ve built a small script with AI that’s actually useful to you, and you can explain every part of it, plus every concept in the table, without looking anything up.

Phase 2: Using LLMs from code and automation (weeks 7–10)#

Do

• Design a CLI chatbot with memory that calls OpenRouter, then have an agent build it with you. You decide how it should work; AI writes it; you explain every part back.
• Learn JSON, APIs, system prompts, temperature, streaming, tool calling, and the cost per call.
• n8n (n8n-io/n8n, self-hostable): build 3 automations, e.g. email triage, a Messenger auto-reply prototype, or a daily AI news digest.
• Work through: microsoft/generative-ai-for-beginners, anthropics/claude-cookbooks, openai/openai-cookbook.

Watch

• n8n Beginner Course (official n8n, 9 parts) · n8n Tutorial: Zero to Hero (freeCodeCamp, 3.5h)
• Build an AI Agent From Scratch in Python (Tech With Tim, 34 min)

Proof you’re done: A chatbot that calls at least one tool (search, weather, a database) and a working n8n workflow that saves you real time.

Phase 3: Agents, RAG, MCP, and agentic coding (weeks 11–16)#

Do

• Build a RAG app over real documents (PDFs, notes) and learn embeddings, chunking, and retrieval.
• Build an agent with tools, then learn MCP (the standard way agents connect to tools).
• Learn evals: how you prove your AI app works instead of eyeballing it.
• Learn context engineering: deciding what goes into the model’s context window, and why it matters more than clever prompts.
• Use dsh, OpenCode, or Aider on a real project in pair mode. Write an AGENTS.md that explains your repo to the agent.
• Courses: Hugging Face Agents Course and LLM Course (free), microsoft/ai-agents-for-beginners, DeepLearning.AI short courses (free, 1–2 hrs each).

Watch

• Learn RAG From Scratch (freeCodeCamp, by a LangChain engineer, 2.5h)
• Full Course (Lessons 1–10): AI Agents for Beginners (Microsoft Developer, 1h)
• Intro to Agents: Create an Agent from Scratch (No Frameworks) (Hugging Face)
• Claude Code: Full Tutorial for Beginners (Tech With Tim, 36 min)
• Build Your Own Agentic Harness in Python (Tech With Tim, 38 min). Build a mini-dsh yourself and you’ll understand every harness.
• What is MCP? (IBM, 4 min) · MCP Explained Simply (TechWorld with Nana, 30 min)
• Context Engineering Explained (Google Cloud Tech, 10 min)
• AI Engineering with Chip Huyen (The Pragmatic Engineer, 1h15)

Proof you’re done: A deployed RAG or agent app, with evals, and a README a stranger could follow.

Parallel track (weekends, optional): how LLMs work under the hood#

You don’t need this to get hired. It’s what separates people who understand AI from people who just use it. Read section 2 first for the big picture.

Watch, in order

1. But What Is a Neural Network? → Gradient Descent → Backpropagation (3Blue1Brown)
2. Transformers, the Tech Behind LLMs → Attention in Transformers, Step by Step (3Blue1Brown)
3. Deep Dive into LLMs like ChatGPT (Karpathy, 3.5h, the best single explainer)
4. Let’s Build GPT: From Scratch, in Code, Spelled Out (Karpathy) · Let’s Build the GPT Tokenizer
5. How Transformer LLMs Work (free course) (Jay Alammar)

Code along: karpathy/nn-zero-to-hero, karpathy/nanoGPT, rasbt/LLMs-from-scratch

Phase 4: Specialize (weeks 17–24+)#

This is where your specialization track starts (see section 9 for all the tracks). The AI + Security track is laid out in full below as an example.

The AI + Security track

This field is short on people. Most security people don’t understand LLMs, and most AI builders don’t think about attacks.

4a. Security fundamentals (you can’t secure what you don’t understand)

• Networking: TCP/IP, DNS, HTTP, subnetting. Use AI tutor mode plus labs.
• OWASP Top 10: the ten most critical web application risks. Learn these first.
• PortSwigger Web Security Academy: free, and the best web-security training anywhere.
• TryHackMe: beginner paths (Pre-Security, then Cyber Security 101).
• picoCTF: free beginner CTFs. Move on to HackTheBox once you’re comfortable.
• Optional cert: CompTIA Security+. It’s the common HR filter. Check which exam version is current before you start studying.

Watch

• How I Would Learn Cyber Security if I Could Start Over in 2026 (6-Month Plan) (UnixGuy)
• You SUCK at Subnetting, EP 1 (NetworkChuck series)
• Professor Messer’s Security+ SY0-701 full course (free, 15h)
• BEGINNER Capture The Flag: PicoCTF “Obedient Cat” (John Hammond)

4b. LLM and agent security

• OWASP Top 10 for LLM Applications: prompt injection, sensitive data leakage, excessive agency, and more.
• OWASP Top 10 for Agentic Applications (2026): risks specific to AI agents that use tools, keep memory, and act on their own.
• Gandalf by Lakera: a prompt-injection game that builds intuition fast.
• PortSwigger: Web LLM attacks: real exploitation labs against LLM-powered features.
• MITRE ATLAS: the ATT&CK-style attack framework for AI systems.
• Tools (all open source):
  • NVIDIA/garak: LLM vulnerability scanner. Easiest place to start.
  • promptfoo/promptfoo: red-teaming and evals that run in CI.
  • Azure/PyRIT: Microsoft’s framework for automated multi-turn attack campaigns.
  • UKGovernmentBEIS/inspect_ai: structured, reproducible evaluations.

Watch

• Prompt Injection, Explained (Simon Willison, who coined the term)
• What Is a Prompt Injection Attack? (IBM, 11 min)
• OWASP’s Top 10 Ways to Attack LLMs (IBM, 25 min)
• Securing AI Agents: Preventing Hidden Prompt Injection (IBM, 10 min)
• Anatomy of an AI Attack: MITRE ATLAS (IBM, 9 min)
• AI Red Teaming 101: Full Course (Episodes 1–10) (Microsoft Developer, 1h17)
• Agentic AI Red Teaming: The Hottest Cyber Skill of 2026 (Cloud Security Guy)
• LLM Vulnerability Scanning with garak: Test Your Own Chatbots (Embrace The Red)
• Promptfoo Red Teaming: A Beginner’s Guide (Jason Koo, 30 min)
• PortSwigger Lab: Exploiting LLM APIs with Excessive Agency (lab walkthrough. Try the lab yourself first.)

4c. The portfolio piece that gets attention

Point garak and promptfoo at the chatbot or agent you built in Phase 3. Find the vulnerabilities, fix them, and publish a redacted red-team report: findings, severity (critical/high/medium/low), fixes, and before/after results.

“I built an AI app, attacked it, and hardened it” is a portfolio most applicants don’t have.

Legal line: Only attack systems you own or have written permission to test. Unauthorized access is a crime under the PH Cybercrime Prevention Act (RA 10175). CTFs, labs, and your own apps are fair game.

8. Landing your first client or job#

The first paying client or job is where all of this starts to make sense. Real constraints, real feedback, real money, and proof that you can deliver. Don’t wait until you finish the whole path. Start reaching out by month 3, sooner if an opportunity shows up.

The fast track: earn while you learn#

This can go faster. If someone you know has a painful problem in week 4, solve it in week 4. The phases are a learning order, not a waiting room.

What you can realistically offer after ~3 months#

You won’t be a senior engineer. You will be able to solve real, common problems that small businesses pay for:

• Lead and inquiry handling: auto-reply to Messenger, website, or email inquiries, qualify the lead, and notify a human
• Booking and scheduling automation: turn messages and forms into calendar entries and reminders
• Data entry elimination: extract data from emails, PDFs, receipts, or forms into a spreadsheet or CRM
• Content workflows: draft social posts, product descriptions, or newsletters from a business’s own material, with a human approving
• Internal knowledge assistant: a simple Q&A bot over a company’s documents and FAQs
• Reporting: pull data from a few tools and send a daily or weekly summary

Every one of these is the same loop from section 4: messy input → process → structured output.

Build a portfolio that gets you hired#

Clients and employers don’t hire certificates. They hire proof you’ve solved a problem like theirs.

For each system you build, publish a GitHub repo with a README that covers:

1. The problem: who had it, and what it cost them (time, money, missed leads)
2. The system map: a before/after diagram (see the diagram tools in section 4)
3. How it works: the flow, the tools, and where AI is used and where humans stay in the loop
4. Results: numbers wherever possible (hours saved, response time, error rate)
5. What I’d improve: this shows judgment, and it’s what interviewers ask about
6. Tech used

This is your AI Engineering Journal (section 15) turned outward. Add a 2-minute demo video (screen recording with your voice) for each one; a free tool like Loom works.

Then share it: post short write-ups on LinkedIn and in relevant Facebook groups for business owners. Focus on the problem solved, not the tech.

Where to find your first client or job#

• People you already know. Family businesses, friends’ shops, former employers or coworkers. The warmest leads close fastest.
• Local businesses with obvious manual work: clinics, salons, real estate agents, schools, restaurants, online sellers. Anyone drowning in Messenger inquiries is a candidate.
• Facebook groups and online communities where business owners hang out and ask for help.
• LinkedIn: both for job posts and for posting your case studies.
• OnlineJobs.ph: the biggest platform for Filipinos working remotely for overseas businesses. Search for automation and AI roles.

Job titles to search: AI Automation Specialist, Automation Engineer (n8n / Make / Zapier), AI Implementation Specialist, AI Operations, Technical VA (AI/automation), Junior AI Engineer, Solutions Engineer. For the security track: SOC Analyst (Tier 1), Security Analyst, and later AI Security / AI Red Team roles.

How to land the first client#

1. Start with a discovery conversation, not a pitch. Ask the systems-thinking questions from section 4: What’s eating your team’s time? Where do leads or orders get lost? What do you do by hand every day?
2. Map their process. Draw the current flow in Excalidraw, mark the bottleneck, and show them a “before and after.” A clear diagram often sells the project better than any demo.
3. Propose a small pilot. One problem, one system, a short timeline, a fixed price. Small and specific beats big and vague.
4. Deliver, measure, and document. Track the before/after numbers from day one.
5. Ask for a testimonial and permission to use it as a case study. That’s what gets you client number two.

On pricing: your first one or two projects can be cheap or even free, in exchange for a testimonial, a referral, and permission to publish the case study. After that, charge properly. Price by the value of the problem solved, not your hours. Raise your rates after every few successful projects.

Applying for jobs#

• Lead with your portfolio, not your background. “Here are 3 systems I built and what they achieved” beats any course list.
• Expect to be tested on how you think: walk through a system map, explain your trade-offs, and talk about what broke and how you fixed it.
• Expect to be asked how you verify AI output. Have a real answer: tests, reviews, evals, human checkpoints (see “You own the output” in section 4).
• Certifications help with HR filters (especially Security+ for security roles), but they won’t get you hired without proof of work.

Using your skills and getting better#

Landing the first client isn’t the finish line. It’s where the compounding starts:

• Notice patterns. When several clients have the same problem, that’s a specialty, or eventually a product (see the survivorship-bias section in section 4 for why this order matters).
• Specialize over time. Pick an industry (clinics, real estate, e-commerce) or a skill (AI security, agents) and become the go-to person for it. Specialists charge more than generalists.
• Keep the learning loop running. Use the daily routine (section 15) even after you’re working. Protect a few hours a week for learning something you’re not paid for yet.

9. Pick a specialization track#

The core path (sections 3–8) gives you the foundation: learning with AI, systems thinking, data handling, automation, and agents. Then you specialize. Specialists get hired faster and paid more than generalists, because businesses search for “someone who can fix our CRM” or “someone who can secure our AI,” not “someone who knows AI.”

You can pick one track, combine two, or switch later. The core skills carry over to all of them. Phase 4 of the path is where your track starts.

The tracks at a glance#

Track 1: AI Automation & Integrations#

This is the default track the core path already builds toward: n8n, AI integrations, agents, MCP, and RAG for businesses.

• Go deeper: advanced n8n (error handling, sub-workflows, queues, self-hosting), building your own MCP servers, evals for production automations, and reusable templates for common client problems.
• Pairs well with: CRM (Track 2) or GTM (Track 3). Most automation work touches a CRM eventually.

Track 2: CRM Management, Automation & Development#

Every business that sells something has a CRM (Customer Relationship Management system), or a messy spreadsheet that should be one. CRM work is steady, in demand, and a natural home for AI automation.

Three levels of the same track:

The main platforms:

• HubSpot: popular with small and mid-size businesses. HubSpot Academy has free courses and certifications.
• Salesforce: the enterprise standard, with the biggest job market. Trailhead is free and gamified, with Admin and Developer paths.
• GoHighLevel: an all-in-one CRM and marketing platform widely used by agencies and small businesses.

Why AI makes this track stronger: CRMs are full of messy data and repetitive steps, which is exactly the “data in → process → structured data out” loop. AI can enrich contacts, score leads, summarize conversations, and draft follow-ups, with the CRM as the system of record.

Watch:

• HubSpot CRM Tutorial for Beginners (Metics Media, 20 min)
• The Only GoHighLevel Tutorial You Need (Charlie Chang, 22 min)

Track 3: GTM Engineering#

GTM (go-to-market) engineering treats sales outreach as a system to be engineered. A GTM engineer builds data pipelines, enrichment workflows, and automated outbound sequences, work that used to take a team of researchers and sales assistants. The role grew up around Clay, a tool for pulling data from many sources, enriching it with AI, and feeding it into outreach and the CRM.

Typical work: finding target companies and contacts, enriching them with data (company size, tech used, recent news), writing personalized outreach with AI at scale, and syncing everything into the CRM.

I tried this track myself (November–December 2025): I used AI and tools like Clay to build outbound outreach systems for businesses. It’s a strong, well-paid track. I didn’t pursue it fully because I prefer working on the sidelines, building systems rather than being close to the sales front line. That’s a good example of how to choose: try a track on a real project before committing to it.

Watch out for: spam and privacy laws. Mass outreach has to follow rules like the PH Data Privacy Act (RA 10173), GDPR in Europe, and CAN-SPAM in the US. Good GTM engineering is targeted and relevant, not mass spam.

Learn it: Clay University (free)

Watch:

• Full Clay.com Course (6+ Hours) (Tim Yakubson and Clay)
• The Only Clay Tutorial You Need (For Beginners) (Xavier Caffrey, 39 min)

Track 4: AI + Security#

Covered in full in Phase 4 of section 7: security fundamentals, LLM and agent security, open-source red-teaming tools, and a red-team report on your own app as the portfolio piece.

The OWASP references every security person should know (OWASP is the nonprofit that publishes the industry’s standard security guides, all free):

Track 5: DevOps / DevSecOps (my track)#

DevOps is about getting software into production and keeping it running: deploying it, monitoring it, fixing it, and keeping the cloud bill honest. DevSecOps builds security into every step instead of bolting it on at the end. AI can write a lot of infrastructure code, but it can’t own an outage at 2am. Someone has to understand the system, and that’s this track.

What you learn, roughly in order:

1. Linux and the terminal
2. Networking (DNS, HTTP, ports, TLS)
3. Git and scripting
4. Containers (Docker)
5. CI/CD pipelines (GitHub Actions)
6. Cloud fundamentals (AWS, Azure, or GCP)
7. Infrastructure as Code (Terraform)
8. Kubernetes (official tutorials)
9. Observability (logs, metrics, alerts)
10. Security: secrets management, least privilege, scanning, using the OWASP DevSecOps Guideline

Map: roadmap.sh/devops

Free structured option: the AWS courses on TESDA, especially AWS Certified Cloud Practitioner (CLF-C02), a good first cloud certification for this track. It’s on my own list too.

Watch:

• Complete DevOps Roadmap 2026: Master These 4 Levels (TechWorld with Nana, 38 min)
• If I Would Start DevOps From 0 (TechWorld with Nana, 10 min)

Track 6: AI-Assisted Software Development (my track)#

This is building real, production software with AI agents, the professional version of “vibe coding.” The difference is the process: specs, plans, tests, reviews, and ownership of what ships (see “You own the output” in section 4).

What you learn:

• The agentic workflow: Claude Code, dsh, or OpenCode, plus AGENTS.md / CLAUDE.md files that teach the agent your codebase
• Spec-driven development: PRD → plan → small tasks → build → test → review (section 4)
• Software concepts that let you direct agents: frontend vs. backend, APIs, databases, authentication, testing, version control, deployment
• Reading and reviewing code: your main job becomes reviewing what agents write, catching mistakes, and making architecture decisions
• Security basics for builders: the OWASP Top 10 and Cheat Sheets from Track 4

Maps: roadmap.sh/full-stack, roadmap.sh/backend, roadmap.sh/ai-engineer

Pairs well with: DevOps (Track 5). Building software and knowing how to ship and run it is a strong combination, and it’s the one I chose.

Track 7: Other tracks worth knowing#

How to choose#

• Try before you commit. Do one small real project in a track before going deep, like I did with GTM engineering.
• Pick what you’d enjoy doing on a bad day. Some people love being close to sales and clients (GTM, CRM); others prefer the sidelines, building and running systems (DevOps, software development).
• Follow demand you can see. If clients keep asking you for the same thing, that’s your track choosing you.
• Combine adjacent tracks: automation + CRM, GTM + CRM, security + DevOps, and software development + DevOps all pair naturally.

10. Roadmaps (roadmap.sh)#

Use these as maps to see where you are, not as checklists to finish. Each node links to free resources.

11. Books#

About “free PDF” links: I’m not linking pirated copies. Most of those sites are unofficial uploads, and pirated-PDF sites are a common way people get malware, which is a bad habit for someone heading into security. Every option below is legally free, or an official free companion to a paid book, and in practice the companion notebooks are where most of the learning happens anyway.

O’Reilly books with free official companions#

Legal shortcut: O’Reilly Learning has a free trial. Plan a reading sprint around it (e.g. AI Engineering plus the LLM security playbook) and cancel before it bills.

Completely free, legal full books#

Essays worth more than most books#

• Building Effective Agents (Anthropic)
• Simon Willison’s prompt-injection series

12. GitHub repos to work with#

How to use a repo to learn, not just to collect stars: clone it, open your agent, and ask “Walk me through this codebase like I’m new. What’s the entry point? What are the 3 most important files?” Then change one small thing yourself and see what breaks.

13. Shortcuts and workarounds#

• Do the $10 OpenRouter top-up once. It’s the biggest return on money in this whole guide.
• Use free government courses. TESDA’s online program has free AWS courses on AI fundamentals, Cloud Practitioner, and AI Practitioner.
• Rotate free models. Each OpenRouter free model has its own daily quota, and OpenCode Zen’s free list rotates too.
• Route models by task: cheap models (DeepSeek V4 Flash or free ones) for grunt work, frontier models for hard thinking.
• Follow one curated feed instead of fifty sources: my AI Reddit multireddit (includes anti-AI subreddits for balance).
• Turn videos into tests: paste a tutorial transcript into AI and ask for a quiz plus a hands-on lab. Watching alone isn’t learning.
• Learn from real repos with an agent as your guide, not only from toy tutorials.
• Use Kaggle and Colab for GPU work instead of buying hardware early.
• Build in public: a GitHub repo plus short write-ups of what broke and how you fixed it will do more for you than certificates.
• When a free tier dies, check OpenRouter’s free LLM API comparison for current limits.
• When stuck, in this order:
  1. Ask AI with full context: the error, what you tried, the relevant code
  2. The official docs, or the tool’s GitHub Issues and Discussions
  3. Ask Jude on Messenger. I’d rather you ask than give up.

14. Traps to avoid#

• Waiting until you feel “ready.” You won’t. Start reaching out by month 3 with what you’ve built.
• Hoarding roadmaps, including this one. Pick one and finish it.
• Chasing every new tool launch. Fundamentals stay; tools change monthly. dsh is great today, but learn the harness concept, not just dsh.
• Paying “AI gurus” for courses or bootcamps early on. Almost everything here is free or close to it.
• Agent-driven copy-paste without understanding what you ship.
• Pasting secrets into free models.
• Downloading pirated PDFs and “cracked” tools. It’s a common malware vector, and a bad look for a security person.
• Attacking systems you don’t own (see RA 10175).
• Treating a chatbot as a friend, therapist, or oracle. It’s a tool that’s trained to agree with you. If you notice yourself losing sleep, pulling away from people, or feeling like the AI “gets” a discovery nobody else understands, step away and talk to a person.
• Copying the SaaS dream from success stories. You’re only seeing the survivors. See section 4.

15. Daily routine, journal, and progress tracker#

Daily routine (~2 hrs/day)#

That last part isn’t optional. Writing it down is how what you learned actually sticks. If you can’t explain it in writing, you haven’t learned it yet. Short on time? Cut the tutorial, never the build or the journal.

AI Engineering Journal#

Keep one entry per project (a Markdown file in your GitHub repo works well). Over 6 months, this journal becomes your portfolio and your interview answers.

## Project: [name]  —  [date]

What I wanted to build:
What I learned:
What went wrong:
How I fixed it:
What I would improve:
Technologies used:
AI tools used (and for what — tutor / pair / delegate):

Sample week, if you’d rather block hours (~10–12 hrs)#

Progress tracker#

• Setup: WSL2/Linux, VS Code, Git, Python, Node. Accounts: GitHub, OpenRouter, ChatGPT, Claude.
• Setup: tutor prompt saved, OpenCode or dsh running with a free model
• Phase 0: I use AI daily and can explain tokens, context window, and hallucination
• Phase 1: Bandit level 15+, can explain every concept in the Phase 1 table, a useful script built with AI that I can explain line by line, everything on GitHub
• Phase 2: CLI chatbot with tool calling, plus a working n8n workflow
• Month 3 milestone: GitHub portfolio with 3+ systems, 2 case studies with diagrams, demo videos. Started applying / reaching out.
• First paid client or job
• Phase 3: deployed RAG or agent app with evals and a README
• Phase 4a: PortSwigger fundamentals, 10+ TryHackMe/picoCTF rooms
• Phase 4b: beaten Gandalf, finished the PortSwigger LLM labs
• Phase 4c: published a red-team report on my own AI app
• Parallel: watched the 3Blue1Brown series and built Karpathy’s GPT

Weekly review log#

16. Glossary#

Plain-language definitions of the terms used in this guide, in alphabetical order.