Diagnose Your Current Skill Level Before Picking a Course

The myth of a single skill level

Most people ask themselves: "Am I a beginner or intermediate?" as if skill is a single number. In reality, you're a mosaic. Maybe you're intermediate at math, beginner at Python coding, advanced at explaining concepts to non-technical people, and advanced at researching but beginner at shipping to production.

Picking a course that assumes uniform skill is like buying shoes one size — something always hurts. If you pick a course that's "Intermediate" but its "Intermediate" is based on assumptions you don't meet, you'll either feel lost (if they assume coding knowledge you lack) or bored (if they assume conceptual depth you've already mastered).

The solution: diagnose yourself on three independent axes. For each axis, answer concrete probe questions and give yourself a level (Beginner / Intermediate / Advanced). The probes matter more than the label. If you can't answer a probe question, you've found a gap.

Axis 1: Conceptual foundation — do you understand why?

This is your understanding of the principles and theory underlying AI, not your ability to code it.

| Level | Probe questions: Can you do these? | |---|---| | Beginner | Explain (to a non-technical friend, without jargon) what a transformer is and why it's useful. You know LLMs use statistics, not magic, but can't articulate the mechanics. You'd struggle to explain why temperature affects LLM randomness. | | Intermediate | Sketch on a whiteboard the rough path from input tokens to output tokens. You understand attention, embeddings, and loss functions exist and have a rough sense of what they do. You can explain why a larger context window helps. You couldn't derive the math, but you know the concepts. | | Advanced | Explain (to another technical person) how attention mechanisms work mathematically. Discuss why temperature affects sampling distribution. Explain how fine-tuning changes model behavior and what layers are most important to tune. You've read at least one research paper, not just blog posts. |

Conceptual foundation in context

Beginner example: You've used ChatGPT a lot. You know it "learns patterns from data" but you'd struggle to explain embeddings or attention. When someone asks "Why is a larger context window useful?" you might say "um, more words?" but can't explain it's about the transformer's ability to attend across more tokens.

Intermediate example: You've completed a course on deep learning fundamentals. You can sketch the transformer architecture and explain attention as "a way to weight which tokens matter most for each position." You understand fine-tuning means "retraining the last few layers," but you couldn't explain why that works or which layers to tune.

Advanced example: You've read papers like "Attention Is All You Need" (Vaswani et al., 2017). You can explain softmax attention, multi-head attention, and why positional encodings are necessary. You understand training objectives (cross-entropy loss) and why instruction-tuning works differently than base model training.

Axis 2: Technical execution — can you build?

This is whether you can use tools and APIs to create working systems, not just understand concepts.

| Level | Probe questions: Can you do these? | |---|---| | Beginner | Follow a step-by-step tutorial and get it working. Copy, paste, and change variable names. You cannot debug when something breaks without the tutorial's solution key or stack overflow. You've completed tutorials but never started from a blank file. | | Intermediate | Build a feature from a written specification ("Create a Q&A chatbot that retrieves from this database and answers questions"). Read error messages and adjust code. Modify an example to fit your use case, changing 20-40% of the code. Debug simple failures (wrong function argument, missing import) but get stuck on subtle issues. | | Advanced | Start from a blank file and design a system. Debug complex issues (why is output quality degrading?) by forming hypotheses and testing them. Read unfamiliar API docs and integrate new libraries. You've shipped 3+ projects and have learned to design systems, not just copy examples. |

Execution in context

Beginner example: You can run the code in a Colab notebook that someone wrote. You can change the model name from "gpt-3.5-turbo" to "gpt-4" and see it work. If it fails with "API key not found," you're stuck.

Intermediate example: You can build a small RAG system if given a tutorial. You follow the steps: load documents, chunk them, embed them, store in a vector DB, retrieve, pass to LLM. If retrieval returns bad results, you experiment with chunk sizes or embedding models. You're learning by doing.

Advanced example: You can design a RAG system from requirements. You decide: "We need sub-second latency, so I'll use a local vector DB. We need accuracy over speed, so I'll add reranking. I'll use Claude because of long context window." You've shipped similar systems before.

Axis 3: Domain experience — how much have you built?

This is the breadth of AI projects you've completed, tools you know, and production issues you've encountered.

| Level | Probe questions: Can you do these? | |---|---| | Beginner | You're new to AI work. You've used ChatGPT but haven't built anything. You don't know what tools exist (Langchain, Hugging Face, etc.) or which to pick for a problem. You've never hit a production issue. | | Intermediate | You've shipped 1-2 small AI projects (a chatbot, a summarization tool, an image generator). You know the main tools and have a sense of tradeoffs (OpenAI is fast and expensive; open models are cheaper but slower). You've hit at least one production issue (slow latency, high cost, hallucination) and fixed it. | | Advanced | You've shipped 3+ AI projects. You have strong opinions on tool tradeoffs backed by experience. You've debugged production issues across multiple dimensions: model choice, prompt engineering, retrieval quality, cost optimization, monitoring. You've hit edge cases and learned to design for them. |

Domain experience in context

Beginner example: You're a software engineer who hasn't touched AI. You know Python but you've never called an LLM API, never chunked documents, never measured retrieval accuracy.

Intermediate example: You've built a simple chatbot with LangChain. You've deployed it, watched the cost ($0.30/day), and realized you needed to optimize. You switched from GPT-4 to GPT-3.5 and saved 70% cost. You've shipped one project but you're still learning what matters.

Advanced example: You've shipped a customer support chatbot, a document summarization pipeline, and a code generation tool. You've experienced hallucinations, latency spikes, and cost overruns. You know which strategies work (better prompts beat bigger models 60% of the time, illustrative estimate). You design for failure modes.

Run your three-axis self-assessment

Go through each axis. For each axis, answer the probe questions honestly. You're not trying to look good; you're trying to find what will block you if you don't address it.

Quick scoring: On each axis, mark yourself as Beginner (B), Intermediate (I), or Advanced (A). You now have a three-letter code: like "BII" (Beginner concepts, Intermediate execution, Intermediate domain) or "IIA" (Intermediate concepts, Intermediate execution, Advanced domain).

Your code tells you what courses will work:

| Code | Recommendation | Why | Avoid | |---|---|---|---| | BBB | Beginner-heavy with lots of worked examples, guided projects, patient explanations. Pair with a 4-week guided cycle. | You need scaffolding on all three axes. | Advanced courses, papers, open-ended projects. | | BII or IBB | Intermediate courses with concept-heavy explanations alongside code examples. Pick courses that teach concepts before coding. | You have one weak axis (concept or domain). The course needs to bridge it. | Courses that assume you know the landscape or can code from requirements. | | IAI or IIA | Intermediate courses with real projects, or mixed-depth courses that let you skip basic sections. | You're uneven. Pick courses that match your weakest axis (I recommend this) and match projects to your domain experience. | Beginner courses (too slow on your strong axes) and purely theory-focused courses (no project validation). | | AIA, AAI, IAA | Project-based learning, papers, advanced tutorials, open-source codebases. You learn best by doing and reading, not watching. | You've got depth. You benefit from less structure and more ownership. | Tutorial-style courses with hand-holding (they feel slow). |

Practice: map your gaps and fill them before the main course

List your three-letter code. Identify which axes are weak (Beginner or lower-than-needed Intermediate). For each weak axis, find a small, targeted resource to fill the gap before enrolling in the main course.

Example profiles and gap-filling strategies:

# My profile: BII (Beginner concepts, Intermediate execution, Intermediate domain)

## Critical gap: Conceptual foundation

I can code and I've shipped projects, but I don't understand *why* RAG works or how embeddings work at all. This will haunt me in an advanced course.

### Gap-filling plan (3-4 hours, this week):

1. **Read:** "What are embeddings?" blog post on Hugging Face blog
   Time: 30 min

2. **Build:** 50-line Python script
   - Load a pre-trained embedding model
   - Embed 5 sentences about AI
   - Calculate cosine similarity between pairs
   - Print results: "Sentence A and B are 87% similar"
   Time: 1 hour

3. **Explain:** Record yourself explaining embeddings to a friend (no notes)
   - "Embeddings are compressed representations of meaning"
   - "They let us measure similarity between text"
   - "Larger models have more accurate embeddings"
   Time: 15 min

4. **Read:** Vaswani et al. "Attention Is All You Need" (skim the attention section)
   Time: 1.5 hours

### Decision:
After this gap-fill, I'm confident enough to start the RAG course. If I still don't get embeddings, I ask the instructor on day 1.

Another example:

# My profile: IBI (Intermediate concepts, Beginner execution, Intermediate domain)

## Critical gap: Technical execution

I understand RAG theory and I've read about it, but I've never *built* anything. I get stuck when the tutorial doesn't explain every line.

### Gap-filling plan (2-3 hours, this week):

1. **Follow:** DeepLearning.AI "LangChain for LLM Application Development" (free, 1 hour)
   - Follow along, don't just watch
   - Run all code in Colab

2. **Modify:** Change one thing in each code sample
   - Different LLM model
   - Different prompt
   - Different retrieval method
   Time: 1 hour

3. **Debug:** Run the code, break it intentionally, fix it
   - Remove the vector DB retrieval, see what fails
   - Change chunk size, measure impact
   Time: 1 hour

### Decision:
After this, I'm ready for an intermediate course that expects me to modify code and debug.

Filling these gaps takes 2-8 hours and unlocks your ability to learn from the main course without constantly feeling lost.

Correcting for Dunning-Kruger: use external validation

Self-assessment has a famous problem: people who are very new (Beginner) and people who are somewhat advanced (Intermediate) both tend to overestimate themselves. Beginners don't know what they don't know. Intermediates are confident enough to not doubt themselves, but not experienced enough to recognize what's hard.

Correction: Use external validation. Don't just say "I'm Intermediate at execution." Find a specific reference and compare.

# Validating my self-assessment

**My claim:** "I'm Intermediate at technical execution"

**Reference point:** "LangChain tutorial on RAG, Week 2 project"

**The test:** Can I do what that tutorial asks in Week 2?
- Build a vector DB
- Index 10 documents
- Retrieve and re-rank top 3
- Pass to LLM for generation

**Honest assessment:**
- [ ] Could I do this without the tutorial? No.
- [ ] Could I modify it (change the LLM, add a filter)? Maybe 50% of the changes.
- [ ] Could I debug if it breaks? Only simple errors.

**Revised assessment:** I'm actually **Beginner at execution**. I followed tutorials but haven't modified them independently. I should fill the gap before starting.

Red flags that you're overestimating:

• You've completed tutorials but never started a project from scratch.
• You can explain code but can't write it without a template.
• You've hit one production issue and fixed it, but only because someone showed you the fix.
• You know tool names but you couldn't pick the right one for a new problem.

If any of these apply, downgrade yourself one level.

Managing mismatched courses

What if you're mixed? For example, Advanced at concepts + Beginner at execution?

Don't assume the course will be boring. A course that's Advanced in concepts might still teach you execution. Example:

• Your profile: IAB (Intermediate concepts, Advanced execution, Beginner domain)
• Course: "Deploying LLMs to production" (assumes you can code, teaches deployment patterns)
• Prediction: This course will be perfect for your domain gap (you'll learn scaling, monitoring, cost optimization). It might be slow on execution (you already know Python), but it'll fill your domain experience.

Recommendation: Pick courses that match your weakest axis, not your strongest.

Common mistake

Do not assume that "I'm Advanced at one thing" means a course will be boring. A course that's Advanced on concepts (deep theory) but Beginner on practice (hasn't shipped anything) can still teach you production reality. You're Advanced at understanding, but Beginner at building.

Similarly, do not assume "I'm Beginner" means you need hand-holding for everything. If you're Beginner at AI but Intermediate at software engineering, an intermediate course that assumes coding skills but teaches AI from the ground up might be perfect. It'll be slow on code but right on concepts.

Choose courses that match your lowest axis, not your average. This ensures you're challenged without being lost.

The long-term payoff of honest self-assessment

Self-assessment is uncomfortable because it forces you to name your gaps. But naming gaps is the prerequisite for closing them. Research on metacognition (Dunning & Kruger, 1999) shows that people who accurately assess themselves learn 2-3x faster than people who overestimate or underestimate. The reason: accurate assessment leads to targeted resource allocation. You don't waste time on topics you already know. You don't struggle silently on topics that need foundational work.

Over a 6-month learning journey, the difference compounds. An honest self-assessor finishes with mastery of 3-4 topics. An overconfident self-assessor finishes with fragments of 10 topics but depth in none.