Building Grasp.study: A Product Course

Differentiate between zero-shot and few-shot prompting with practical examples.

Write effective system prompts that define an LLM's persona, role, and task.

Use Claude-specific XML tags to structure prompts and guide the model's output.

Apply chain-of-thought prompting to break down complex tasks into explicit reasoning steps for the LLM.

Design reusable prompt templates with variable placeholders that request structured JSON output.

Identify and debug common prompt failure modes by analyzing LLM outputs against expected results.

Design a reusable prompt template that accepts a learning goal and outputs a structured syllabus in JSON format.

Write a Python script to test the syllabus generation prompt with sample inputs and validate the JSON response structure.

Use Claude to detect whether a user-provided learning goal is ambiguous or overly broad.

Design a prompt to generate clarifying questions or narrower sub-topics for problematic user goals.

Create a multi-step prompt chain that first generates high-level modules, then generates learning outcomes for each module.

Implement a critique-and-refine chain where one Claude call critiques a generated syllabus and a second call refines it based on the feedback.

Validate LLM-generated JSON output against a predefined schema using Python.

Orchestrate the complete syllabus generation logic within a single Python function.

Project Milestone: Build a command-line interface (CLI) tool that integrates goal validation, chained syllabus generation, and formatted console output.

Design the database schemas for users, courses, and lessons using Pydantic models.

Create asynchronous API routes with path and query parameters in FastAPI.

Connect to a MongoDB database from a FastAPI application using the `motor` async driver.

Build a user registration endpoint and implement JWT-based authentication for login.

Create a reusable FastAPI dependency to decode JWTs and protect sensitive endpoints.

Implement CRUD (Create, Read, Update, Delete) API endpoints for managing courses and their content.

Project Milestone: Test the API server's authentication flow and all CRUD operations for courses using an API client like Postman.

Explain how text embeddings represent the semantic meaning of text as numerical vectors.

Generate text embeddings for document chunks using a third-party embeddings API (e.g., OpenAI, Voyage AI).

Calculate cosine similarity between two embedding vectors to measure their semantic closeness.

Set up and manage a local vector database using ChromaDB.

Store text documents along with their embeddings and metadata in ChromaDB.

Query the vector database to retrieve documents based on semantic similarity to a search query.

Apply metadata filters to refine vector search results.

Project Milestone: Build and test a Python function that accepts a text query and returns the most semantically similar documents from the vector store.

Describe the Retrieval-Augmented Generation (RAG) architecture and its benefits for question-answering.

Extract clean, readable text from web pages by stripping HTML markup using the `BeautifulSoup` library.

Split large documents into smaller, overlapping chunks suitable for embedding.

Orchestrate a pipeline that extracts text from a URL, chunks it, generates embeddings, and indexes the chunks in a vector database.

Implement the retrieval step to fetch the most relevant document chunks for a given user query.

Construct a prompt that combines the retrieved context with the user's query to generate a grounded response from Claude.

Compare a RAG-augmented response with a standard LLM response to evaluate the reduction in hallucinations.

Project Milestone: Create a test script that indexes an educational article and uses the RAG pipeline to answer questions about its content.

Use a web search API (e.g., Tavily, Serper) to find relevant URLs for a given learning topic.

Retrieve and parse video transcripts using a third-party API or library.

Define a unified Pydantic model to represent content chunks from diverse sources (articles, videos) with common metadata.

Implement processor functions to transform raw article content and video transcripts into the unified chunk model.

Write a prompt that uses Claude to evaluate and score a list of resources based on relevance and quality.

Implement robust error handling for the multi-step resource curation pipeline (e.g., failed API calls, content extraction errors).

Implement the orchestration function that chains search, content retrieval, processing, and Claude-based evaluation.

Project Milestone: Expose the complete resource curation pipeline as a FastAPI endpoint and test it with sample learning topics.

Design a prompt to generate detailed lesson content based on a set of curated resources.

Incorporate specific consumption instructions (e.g., 'read pages 5-10', 'watch from 2:30 to 5:00') into the generated lesson content.

Define a Pydantic model for the complete lesson structure, including content, resources, and exercises.

Generate multiple-choice practice questions with correct answers and explanations using a Claude prompt.

Implement backend logic to validate a user's submitted answer for a practice question.

Orchestrate the full lesson creation pipeline: resource curation, content generation, and exercise creation.

Index generated lesson content into the vector database to enable Q&A on the material.

Project Milestone: Expose the lesson generation and lesson Q&A functionalities as separate FastAPI endpoints.

Scaffold the React application with components for goal input, syllabus view, and lesson viewing.

Configure an API client (e.g., Axios) to communicate with the FastAPI backend.

Implement the goal submission form to call the syllabus generation endpoint and render the response.

Implement streaming from the FastAPI backend to display generated content in real-time in the React UI.

Build the lesson viewer component to display curated resources, consumption instructions, and generated lesson content.

Create interactive exercise components with answer submission and validation feedback.

Build the AI mentor chat interface and connect it to the backend RAG-based Q&A endpoint.

Project Milestone: Wire up navigation between all views and perform a full user journey test from goal input to lesson completion.

Extend the user database model with fields for learner profile data (e.g., background, preferences).

Implement API endpoints for creating, retrieving, and updating learner profiles.

Implement API endpoints and database logic to track user progress through lessons and modules.

Modify syllabus generation prompts to incorporate and adapt to user profile data.

Implement an API endpoint to capture and store user feedback on course content.

Write a prompt that uses Claude to classify user feedback (e.g., 'too easy', 'irrelevant') and suggest syllabus modifications.

Implement the backend logic to trigger a personalized syllabus regeneration based on user feedback and progress data.

Project Milestone: Build the frontend feedback interface, display user progress, and test the adaptive syllabus update flow.

Implement a caching strategy (e.g., Redis) to reduce redundant Claude API calls and improve response time.

Implement cost tracking by capturing token usage from Claude API responses and storing it.

Configure environment variables and secrets management for production security.

Write a Dockerfile to containerize the FastAPI backend application.

Use Docker Compose to define and run the multi-container application (backend, database, cache).

Deploy the full application to a cloud platform like Render or Railway.

Perform post-deployment checks on user registration, login, and core feature functionality.

Project Milestone: Complete production testing by verifying the entire user flow, including AI mentor chat and feedback-driven updates.