Claude Code Crash Course For Developers

Learn to use Anthropic's Claude Agent SDK (formerly Claude Code SDK) for AI-powered development workflows! https://platform.claude.com/docs/en/agent-sdk/overview https://x.com/trq212 **AI Summary** This workshop by Thariq Shihipar (Anthropic) details the architecture and implementation of the **Claude Agent SDK**. The session moves from high-level theory—defining "agents" as autonomous systems that manage their own context and trajectory—to a live-coding demonstration. Shihipar builds an agent "Harness" from scratch, implementing the core **Agent Loop** (Context Thought Action Observation), integrating the **Bash tool** for general computer use, and demonstrating **Context Engineering** via the file system to maintain state across long tasks. **Timestamps** 00:00 Introduction: Agenda and the "Agent" definition 05:15 The "Harness" concept: Tools, Prompts, and Skills 10:10 Live Coding Setup: Initializing the Agent class and environment 15:45 implementing the "Think" step: Getting the model to reason before acting 25:20 The Agent Loop: connecting `act`, `observe`, and `loop` 33:10 Tool Execution: Handling XML parsing and tool inputs 42:00 The "Bash" Tool: Giving the agent command line access 49:30 Safety & Permissions: "ReadOnly" vs "ReadWrite" file access 58:15 Context Engineering: Using `ls` and `cat` to build dynamic context 01:05:00 The "Monitor": Viewing the agent's thought process in real-time 01:12:45 Handling "Stuck" States: Feedback loops and error correction 01:21:20 Multi-turn Complex Tasks: Building a "Research Agent" demo 01:35:10 Refactoring patterns: "Hooks" and deterministic overrides 01:48:39 Q&A: Reproducibility, helper scripts, and non-determinism 01:50:31 Q&A: Strategies for massive codebases (50M+ lines) 01:52:00 Closing remarks and future SDK roadmap * **Evolution of AI Capabilities:** Shihipar argues we are shifting from **LLM Features** (categorization, single turn) to **Workflows** (structured, multi-step chains like RAG) to **Agents**. He defines agents as systems that *"build their own context, decide their own trajectories, and work very autonomously"* rather than following a rigid pipeline. * **The Claude Agent SDK Architecture:** The SDK is built directly on top of **Claude Code** because Anthropic found they were *"rebuilding the same parts over and over again"* for internal tools. * **The Harness:** A robust agent requires more than just a model; it needs a "Harness" containing Tools, Prompts, a **File System**, Skills, Sub-agents, and Memory. * **Opinionated Design:** The SDK bakes in lessons from deploying Claude Code, specifically the "opinion" that general computer use (Bash) is often superior to bespoke tools. * **The Power of the Bash Tool:** A key technical insight is that the **Bash tool** is often the most powerful tool for an agent. Instead of building custom tools for every action (e.g., a specific API wrapper for a file conversion), giving the agent access to the shell allows it to use existing software (like `ffmpeg`, `grep`, or `git`) to solve problems flexibly, similar to how a human developer works. * **Context Engineering:** Shihipar introduces the concept of **Context Engineering** via the file system. Instead of just "Prompt Engineering," the agent uses the file system to manage its state and context. * **Files as Memory:** The agent can write to files to "remember" things or create its own documentation (e.g., `CLAUDE.md`) to ground future actions. * **Verification:** The file system serves as a ground truth for the agent to verify its work (e.g., checking if a file was actually created). * **The Agent Loop & Intuition:** Building a successful agent loop is described as *"kind of an art or intuition"*. The loop generally follows a **Gather Context Take Action Verify Work** cycle. Shihipar emphasizes that this loop allows the agent to self-correct, a capability missing from rigid workflows. * **Strategies for Determinism (Hooks):** During the Q&A, a technique for controlling agent behavior is discussed: **Hooks**. * If an agent hallucinates or skips a step (e.g., guessing a Pokemon stat instead of checking a script), a hook can intercept the response and inject feedback: *"Please make sure you write a script, please make sure you read this data."* * This enforces rules like "read before you write" without retraining the model. * **Scaling to Large Codebases:** For massive codebases (50M+ lines), standard tools like `grep` or basic context window stuffing fail. * **Semantic Search Limitations:** Shihipar notes that while semantic search is a common solution, it is *"brittle"* because the model isn't trained on the specific semantic index. * **Solution:** He recommends good **"Claude MD"** files (context files) and starting the agent in a specific subdirectory to limit scope, rather than trying to index the entire 50M lines at once.

AI Fluency: Framework & Foundations is a course developed by Anthropic, Prof. Rick Dakan (Ringling College of Art and Design) and Prof. Joseph Feller (University College Cork). View the full free course, including all videos, exercises, and resources, at https://www.anthropic.com/ai-fluency

Get started with Codex, OpenAI’s coding agent, in this step-by-step onboarding walkthrough. You’ll learn how to install Codex, set up the CLI and VS Code extension, configure your workflow, and use Agents.md and prompting patterns to write, review, and reason across a real codebase. This video covers: Installing Codex (CLI + IDE) Setting up a repo and getting your first runs working Writing a great Agents.md (patterns + best practices) Configuring Codex for your environment Prompting patterns for more consistent results Tips for using Codex in the CLI and IDE Advanced workflows: headless mode + SDK Start here Sign up: https://openai.com/codex/ Codex overview + docs: https://developers.openai.com/codex Codex Cookbook: https://cookbook.openai.com/topic/codex Install + setup VS Code extension: https://marketplace.visualstudio.com/items?itemName=openai.chatgpt Agents.md standard: https://agents.md Agents.md repo: https://github.com/agentsmd/agents.md Prompting + workflows Prompting guide: https://developers.openai.com/codex/prompting/ Exec plans (Agents.md patterns): https://cookbook.openai.com/articles/codex_exec_plans Config reference: https://github.com/openai/codex/blob/main/docs/config.md#config-reference Updates Changelog: https://developers.openai.com/codex/changelog Releases: https://github.com/openai/codex/releases

Watch us build a complete real-time polling app using ONLY AI! Andrew Stewart (@srcrip) & Daniel Bergholz (@DanielBergholz) join me as we let Claude Code + Tidewave do ALL the coding. No manual code writing allowed! We built authentication, real-time voting, dynamic forms, live updates, and a polished UI - all through AI prompts. The result? A fully functional Phoenix LiveView app with 13 commits in just 2 hours! 00:00 - Introduction and sponsor message 04:00 - Setting up the live coding challenge and polling the audience 09:00 - Introducing Claude Code and the wild card project selection 15:25 - Installing and configuring Claude Code for the first time 23:30 - Setting up Tidewave MCP for Elixir integration 32:00 - Creating the Phoenix project and initial setup 40:00 - Building polls schema and embedded options 48:00 - Implementing Phoenix authentication with gen.auth 1:05:00 - Creating live views and dynamic forms 1:20:00 - Adding real-time voting functionality with PubSub 1:27:00 - Debugging with Tidewave's powerful runtime integration 1:35:00 - Building authorization and user permissions 1:45:00 - Adding vote changing functionality and UI polish 1:55:00 - Creating a stunning homepage with Claude's design skills 2:05:00 - Setting up GitHub workflow and creating pull request 2:15:00 - Wrap-up and reflections on AI-assisted development Tools Used: Claude Code (agentic terminal AI) Tidewave MCP (Elixir runtime integration) Phoenix LiveView + Tailwind CSS Judge Our Vibe Code: Open PR: https://github.com/ElixirMentor/pulse_vote/pull/1 Connect: Andrew: @srcrip Daniel: @DanielBergholz Support Elixir Mentor: https://elixirmentor.com/?utm_source=elixir-mentor #TideWave #ClaudeCode #ElixirLang #PhoenixFramework #AIcoding #VibeCoding #LiveView #ElixirMentor

Learn how to use the OpenAI's Assistants API to build powerful AI assistants. In this course, we'll explore how to leverage the Assistants API by OpenAI to create dynamic, intelligent web apps using Streamlit. What we'll cover: 1️⃣ Function Calling with the API: Learn to seamlessly integrate the Assistants API into your applications, enabling advanced AI functionalities right at your fingertips. 2️⃣ Knowledge Retrieval: Discover how to use the API to extract information, answer questions, and make your applications smarter and more responsive. 3️⃣ Code Interpreter Capabilities: Dive into the API's ability to interpret and generate code, a game-changer for automating tasks and enhancing your app's capabilities. 4️⃣ LLM Fundamentals: Gain a solid understanding of Large Language Models (LLMs) and how they form the backbone of OpenAI's Assistants API. This module demystifies the technology and provides a foundation for advanced application development. The course features a series of hands-on projects and real-world examples to apply what you've learned. By the end of our session, you'll have the skills and confidence to build your own intelligent web apps using Streamlit and OpenAI's Assistants API. ⭐️ Code ⭐️ Personal trainer: https://github.com/pdichone/vincibits-personal-trainer-assistant Personal trainer: https://github.com/pdichone/vincibits-personal-trainer-assistant Study-Buddy: https://github.com/pdichone/vincibits-study-buddy-knwoledge-retrieval ✏️ Created by @vincibits Twitter (X): @buildappswithme ❤️ Try interactive AI courses we love, right in your browser: https://scrimba.com/freeCodeCamp-AI (Made possible by a grant from our friends at Scrimba) ⭐️ Contents ⭐️ ⌨️ (0:00:00) Introduction ⌨️ (0:01:02) What’s This Course About - What Will You Learn? ⌨️ (0:01:33) Pre-requisites ⌨️ (0:02:44) Python and Dev tools Set up ⌨️ (0:04:22) VS Code Installation ⌨️ (0:05:31) OpenAI Account - Generate an API Key ⌨️ (0:07:53) What is the Assistants API & Benefits - Comparison Between the Chat Completion API and the Assistants API ⌨️ (0:18:16) Assistants API Building Blocks ⌨️ (0:24:04) Creating an Assistants API - Manually (Personal Trainer) ⌨️ (0:38:20) Creating an Assistants API - In Code (Personal Trainer) ⌨️ (1:04:15) Build a News Summarizer Introduction: Function Calling - A Streamlit Application ⌨️ (1:25:39) Create an AssistantsManager Class For our News Summarizer ⌨️ (2:10:46) Using the AssistantManager Class to Create an Assistant and run it as a Streamlit App ⌨️ (2:28:23) Knowledge Bases Retrieval Tools - How it Works & Introduction to Embeddings ⌨️ (2:35:25) Build a Study Buddy Streamlit Application ⌨️ (3:22:24) Run the Study Buddy Streamlit Application and Test ⌨️ (3:29:27) Wrap up and Final Considerations. 🎉 Thanks to our Champion and Sponsor supporters: 👾 davthecoder 👾 jedi-or-sith 👾 南宮千影 👾 Agustín Kussrow 👾 Nattira Maneerat 👾 Heather Wcislo 👾 Serhiy Kalinets 👾 Justin Hual 👾 Otis Morgan 👾 Oscar Rahnama -- Learn to code for free and get a developer job: https://www.freecodecamp.org Read hundreds of articles on programming: https://freecodecamp.org/news

There's a lot of new terms for how you manage context with coding agents. I don't think it needs to be this complicated. Here's what you need to know, and some history on how we've gotten here. https://cursor.com/blog/dynamic-context-discovery https://cursor.com/docs/context/skills https://cursor.com/docs/context/subagents https://cursor.com/docs/context/rules https://cursor.com/docs/agent/hooks