I’ve been learning JavaScript and Vue (and re-learning Python) with Claude as my coding partner. I will share some findings and tricks when learning from AIs. Note: I’m (sort of) intermediate for Python and a novice for JS/Vue.

AIs are trained to help, not to teach

If you use general chat AIs such as ChatGPT, Gemini, Claude or Grok, they tend to give your full working source files from the beginning. This is not good for your learning.

LLMs/AIs are trained with StackOverflow or similar websites where people tend to give code snippets as answers for a question. So, AIs think it would be helpful to give code. What LLMs don’t understand is that people who ask questions usually have gone through long troubleshooting before asking questions on the Internet.

If you just copy and paste what AI offers, you are not learning anything. It’s called vibe-coding. You can ship an app quick, but you don’t understand it.

So, you need to ask explicitly to your partner AI not to give code. This needs to be in every chat session. Even then, AI sometimes forgets your instruction and offers code snippets to you. You need to refuse them.

But again, you sometimes DO want code snippets, and you might want to tell AI like:

Don’t give me code snippet first. But give one to me when you see I’m struggling.

I wouldn’t do this because the instruction is ambiguous (eg, what is “first”? Is 2nd time ok?), and it’s a bit complex for an AI to remember it in long chat sessions. Yes, AIs are forgetful.

This is my instruction to Claude.

## Learning Approach
Problem-by-problem
Don't give code snippets (or fully working code) — guide toward the solution
Guide with questions and links to docs

The “problem-by-problem” instruction is helpful if you are a beginner. Beginners are easily overwhelmed by too much information or too challenging assignments. It’s important that you are given digestible amount of problems one at a time.

Combine multiple AIs

Then what if I want code snippets? I ask Grok. Actually, I tend to ask Grok when some keywords in answers from Claude are unfamiliar to me. For example, I might ask:

what is py-4 for tailwindcss? How can I insert space below a line?

And Grok explains to me what ‘p’ and ’m’ are in details with examples. Grok is also good for this purpose because it usually gives me latest information whereas Claude and Gemini sometimes provide obsolete or deprecated info.

This way, Claude can focus on the main topic, with an additional benefit of saving token usage.

As a beginner, you encounter new concepts often during development. In such a case, I ask “Explain to me X (new concept)” to multiple AIs. Reading more than one explanation helps for an unfamiliar concept to stick in your head. If it’s an important concept, additional Q&As will deepen your understanding.

When troubleshooting gets long and if I find Claude starts saying something off, I switch to ChatGPT. GPT-5.5’s reasoning is very strong. Also, it’s good for you to step back a little and explain the problem to a different AI.

I don’t use ChatGPT as a coding partner because it is way too talkative for my liking and I will easily hit its usage limit. I reserve ChatGPT until I really need it.

To summarize:

  • Learn - Claude
  • Look up - Grok
  • Debug - ChatGPT

and Gemini and DeepSeek for 2nd opinions and more explanations

Switch to a new chat every day

If you use free tiers, you’d want to save the number of questions (prompts) as well as tokens. As we saw recently that Google has moved Gemini to compute-based usage limit, I think competitors are likely to follow the big G in the near future because compute usage is the actual cost for them, and the number of tokens is directly linked to it.

To save tokens, switching to a new chat once in a while is a good practice. Every token LLM produces require computation (ie, attention) against all other tokens in the chat session. The cost of generating a single new token is in proportion to the length of the session.

But LLM, in my case Claude will forget the context if I start a new session. So, I ask Claude to summarize the current context in plain text at the end of the previous session, and paste it in a new chat.

It technically doesn’t have to be every day, but I feel it’s similar to what we do. Refreshing every day after a good night sleep.

This is an actual example Claude gave to me.

# Project: agnt3 (Sandbox Compliance Officer)

## Core Objective
A type-safe, protocol-oriented AI agent system for HR/Compliance automation.
Features a Human-in-the-loop (HITL) gate to prevent autonomous execution
of high-stakes actions without manual dashboard approval.
Tech Stack (2026 Standards)

Brain: PydanticAI (Agent Framework) + Ollama (qwen3:8b reasoning model)
Protocol: Model Context Protocol (MCP) Python SDK (Decoupled tool layer)
Data: SQLite + SQLAlchemy (Async) for Audit Logs (HOTL) and HITL states
Frontend: Vue 3 (Vite 7) + DaisyUI/Tailwind (Dashboard & Monitoring)
Infrastructure: N150 Ubuntu Server (Lab) + M1 Pro Mac (Dev)

## Architectural Workflow
Request: Mock HR request (e.g., PTO/Expense) is ingested.
Reason: Agent uses MCP tool to read local policy docs (.org/.md).
Gating: If violation detected, Agent writes "PENDING" to SQLite.
HITL: Vue 3 UI detects pending state; User clicks Approve/Deny.
Audit: All steps are recorded in a DaisyUI Timeline for HOTL review.

## Implementation Roadmap
Ph 1: Build MCP Server for local policy I/O and system metrics.
Ph 2: Configure PydanticAI Agent with tool-calling via Ollama.
Ph 3: Develop SQLite/SQLAlchemy layer for async state persistence.
Ph 4: Construct Vue 3 Dashboard with DaisyUI 'stats' and 'timeline'.

## Project State
Problem 1 complete: scaffold created, pyproject.toml configured
Dependencies: pydantic-ai-slim[mcp], mcp, sqlalchemy[asyncio], aiosqlite, ollama
Directory layout: mcp/, agent/, db/, fe/, policy/, main.py, agnt3.org
MCP transport decision: streamable-http (not SSE; SSE is being deprecated)
Next: Problem 2 — implement mcp/server.py with read_policy tool

## Learning Approach
Problem-by-problem (same pedagogy as ragev frontend project)
Don't give complete code first — guide toward the solution
Concise answers with links to official docs where relevant
Prefer complete files over diffs when code is eventually provided
No asterisk-based bullet/header formatting (org-mode compatibility)