DEV Community: Jayesh Padhiar

Claude Code: A Beginner's Complete Guide

Jayesh Padhiar — Thu, 26 Mar 2026 17:31:00 +0000

I just finished Anthropic's "Claude Code in Action" course, and I want to break down everything I learned — from installation to advanced workflows — so you can skip the fumbling-around phase and start being productive immediately.

What Is Claude Code, Really?

Claude Code is an agentic coding tool that lives directly in your terminal. Not a VS Code extension. Not a browser tab. Your terminal — the place where you already live as a developer.

What makes it different from pasting code into ChatGPT is the word agentic. Claude Code doesn't just answer questions — it takes action. It reads your files, understands your project structure, runs commands, edits code, manages git workflows, and executes multi-step tasks — all through natural language.

Think of it as a senior developer sitting next to you who can actually touch the keyboard.

Installation and Setup

Getting started takes about two minutes.

# Install globally via npm
npm install -g @anthropic-ai/claude-code

# Navigate to your project
cd your-project

# Launch Claude Code
claude

You'll need an active Anthropic API key or a Claude Pro/Max subscription. On first launch, it'll walk you through authentication — just follow the prompts.

Once you're in, the first command you should run is:

/init

This tells Claude to analyze your project and generate a CLAUDE.md file — essentially a memory file that stores your project's conventions, build commands, tech stack, and patterns. More on this later, because it's one of the most powerful features.

The Command Reference You'll Actually Use

Here's where most guides lose people — they either show you three commands or dump fifty on you with no context. I'm going to walk through every command that matters, grouped by when you'll actually reach for them.

Everyday Essentials

/help — Your safety net. Forgot a command? Start here. It lists everything available with brief descriptions.

/clear — Resets your conversation. Use this more than you think you should. Every time you switch tasks, clear the chat. Old context eats tokens and can confuse Claude about what you're currently working on.

/compact — When your conversation gets long but you're not ready to start fresh, /compact compresses the history while preserving essential context. Think of it as "summarize and continue" — you keep the thread alive without burning through your context window.

/cost — Shows your token usage for the current session. Get in the habit of checking this periodically, especially during long sessions. It helps you understand which types of prompts are expensive and which are cheap.

/status — Quick health check. Shows your current authentication state, model, and session info.

Project Setup and Memory

/init — Generates a CLAUDE.md file by analyzing your project. Run this once when you start using Claude Code in a new repo. It creates a foundation of project knowledge that persists across every future session.

/memory — Opens your CLAUDE.md for direct editing within the session. This is your shortcut to durable customization — every instruction you add here improves every future session.

Here's the thing about CLAUDE.md that the course really emphasizes: it works in a hierarchy.

~/.claude/CLAUDE.md          → Global (applies everywhere)
./CLAUDE.md                   → Project root (applies to this repo)
./CLAUDE.local.md             → Local project (gitignored, personal prefs)
./src/tests/CLAUDE.md         → Directory-specific (applies in /tests)

Your global file might say "always use TypeScript strict mode." Your project file might say "we use Vitest, not Jest." A subdirectory file might say "tests in this folder follow the AAA pattern." Claude reads them all and prioritizes the most specific one when relevant.

Pro tip: Put your team's coding standards, preferred patterns, and common commands in the project-level CLAUDE.md and commit it. Now every developer on your team gets the same Claude experience.

Code Review and Quality

/review — Triggers a code review of your current changes. This is incredibly useful before committing. Claude examines your diffs and flags potential bugs, security issues, and style inconsistencies.

You can customize the review focus too. Instead of getting a verbose review of everything, tell Claude what to focus on:

/review Focus on security vulnerabilities and potential null pointer exceptions only

Configuration and Troubleshooting

/config — Adjust Claude Code settings like your default model, theme, and behavior preferences.

/doctor — When something isn't working right, /doctor runs diagnostics on your setup. It checks your authentication, network connectivity, configuration, and common issues. Run this before spending twenty minutes debugging manually.

/login and /logout — Manage your authentication. If you switch between accounts or your session expires, these are straightforward.

/bug — Found something broken in Claude Code itself? This command helps you file a bug report directly to Anthropic with relevant context automatically included.

The Shortcuts That Save Hours

Beyond slash commands, there are keyboard shortcuts and syntax tricks that dramatically speed up your workflow.

@ to reference files — Instead of describing which file you mean, just reference it directly:

Look at @src/components/Auth.tsx and fix the login validation

Claude will read that specific file and work with it. You can reference multiple files in a single prompt.

Tab for autocomplete — When typing file paths after @, hit Tab to autocomplete. It works just like your shell's tab completion.

Escape — Cancels Claude's current response mid-stream. Changed your mind about a prompt? Hit Escape and the generation stops immediately.

Ctrl+C — Interrupts the current operation. Useful when Claude is running a command that's taking too long or you realize you asked for the wrong thing.

# to add memory notes — Prefix a message with # and it won't be sent as a regular prompt. Instead, Claude will offer to save that information directly to your CLAUDE.md memory file. It's a quick way to build up your project memory while you work:

# We use Vitest for testing, never Jest
# All API responses follow the { data, error } pattern

Think of it as a self-documenting shortcut — jot down conventions and patterns the moment you encounter them, without breaking your flow.

! to run shell commands — Prefix any command with ! to run it directly in your terminal without leaving the Claude session:

!npm run test

Extended Thinking: When You Need Claude to Really Think

One of the most powerful features covered in the course is extended thinking. By default, Claude responds quickly with standard reasoning. But for complex problems — architectural decisions, tricky debugging, multi-file refactors — you want Claude to think deeper.

You can trigger this by simply asking Claude to "think harder" or "think step by step" about a problem. The course also mentions explicit thinking keywords:

"think" — Standard extended reasoning
"think hard" — More thorough analysis
"ultrathink" — Maximum reasoning depth

The difference is noticeable. For simple tasks, standard mode is fine and faster. For "why is this race condition happening across three services" — you want ultrathink.

The Permissions Model: Your Safety Net

Claude Code uses a layered permissions system, and the course spends real time on this because it matters.

When Claude wants to do something potentially impactful — editing a file, running a shell command, making a network request — it asks for permission first. You'll see prompts like:

Claude wants to run: npm install lodash
Allow? (y/n/always)

The three permission categories are:

Read — Which files Claude can see
Edit — Which files Claude can modify
Bash Commands — Which terminal commands Claude can execute

You can pre-approve commands to avoid repetitive prompts:

# Allow all npm test commands
/permissions allow "npm run test:*"

The course emphasizes a principle that stuck with me: treat Claude like a powerful but untrusted intern. Give it only the permissions it needs. Don't blanket-allow everything. If you're working on a personal project and want to move fast, you can be more permissive. In a production environment, lock it down.

MCP: Connecting Claude to Your Tools

MCP — Model Context Protocol — is what takes Claude Code from "smart terminal assistant" to "integrated development platform." It's an abstraction layer that lets Claude interact with external tools and services.

Want Claude to query your database directly? Set up a database MCP server. Want it to run Playwright tests and read the results? There's an MCP server for that. Want it to interact with your project management tool? Same idea.

Configuration lives in .claude/settings.json:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"]
    }
  }
}

Once configured, Claude can invoke these tools naturally during your conversation. You ask "run the E2E tests for the login flow," and Claude uses the Playwright MCP server to execute them and report back.

The key insight from the course: put MCP config in your repo's .claude/settings.json and commit it. Now every team member gets the same tool integrations automatically.

Custom Slash Commands: Your Personalized Shortcuts

This is one of those features most people miss, and it's genuinely powerful.

Create a .claude/commands folder in your project, add markdown files named after your commands, and write the instructions in natural language:

<!-- .claude/commands/deploy-check.md -->
Run the following checks before deployment:
1. Run the full test suite
2. Check for any TypeScript errors
3. Verify no console.log statements in production code
4. Review the git diff for any sensitive data
Report results as a checklist with pass/fail for each item.

Now you can run /deploy-check anytime. You can also use $ARGUMENTS for dynamic input:

<!-- .claude/commands/explain.md -->
Explain the function or module at $ARGUMENTS in simple terms.
Include: what it does, why it exists, and how it connects to the rest of the codebase.

Usage: /explain src/utils/auth.ts

A word of caution from the course: don't go overboard. Keep custom commands simple and personal. If your slash command is fifty lines long, that logic probably belongs in your CLAUDE.md instead.

Headless Mode and CI/CD Integration

This is where Claude Code gets seriously interesting for teams.

Headless mode (--print or -p) runs Claude without the interactive interface — perfect for scripts, automation, and CI/CD pipelines:

# Use in a script
claude -p "Review the changes in this PR and list any security concerns"

# Pipe output
claude -p "Generate a changelog from the last 10 commits" > CHANGELOG.md

In CI/CD, you can use Claude Code for automated code reviews, PR descriptions, test generation, and more:

# Example GitHub Action step
- name: AI Code Review
  run: |
    claude -p "Review the diff in this PR. Focus on bugs and security issues. Output as markdown." > review.md

For security in CI/CD, use the --allowedTools flag to restrict exactly which tools Claude can access:

claude -p --allowedTools "Read,Grep,Glob" "Analyze this codebase for dead code"

This prevents an injected prompt from triggering destructive actions in your pipeline.

Hooks: Deterministic Control Over Claude's Behavior

Hooks are shell commands that execute automatically at specific points during Claude's workflow. They're the "must-do" rules that complement the "should-do" suggestions in your CLAUDE.md.

You can configure hooks through the interactive /hooks command or by editing your settings JSON directly. Common hook events include things like running before Claude processes your prompt, after it edits a file, or before it commits code.

Example use case: automatically run your linter every time Claude edits a file, ensuring every change meets your code standards before you even review it.

Prompt Engineering Tips for Claude Code

The course covered practical prompting strategies that are specific to a terminal-based agentic tool — different from how you'd prompt a chat interface:

Be specific about scope. Instead of "fix the bugs," say "fix the null pointer exception in @src/auth/login.ts on line 42."

Use multi-step instructions for complex tasks. Claude handles sequential instructions well:

1. Read the test file at @tests/auth.test.ts
2. Identify which tests are failing
3. Fix the implementation in @src/auth.ts to make them pass
4. Run the tests to verify

Start fresh often. Use /clear between unrelated tasks. Context pollution is real and it degrades response quality.

Front-load context. If Claude needs to know something about your project that isn't in CLAUDE.md, say it at the beginning of your prompt, not the end.

Let Claude explore. Instead of telling Claude exactly which file to look at, sometimes it's better to say "find where we handle user authentication" and let it search. It's surprisingly good at codebase navigation.

Cost Management: Keeping Your Bill Reasonable

A few practical tips from the course:

Use /compact proactively — Don't wait until you hit context limits. Compact every 15-20 exchanges in a heavy session.
Use /clear between tasks — Fresh context is cheaper than bloated context.
Check /cost regularly — Awareness alone changes behavior.
Match thinking depth to task complexity — Don't use "ultrathink" for renaming a variable.
Write good CLAUDE.md files — The better your memory files, the less back-and-forth Claude needs, which directly reduces token usage.
Use headless mode for repetitive tasks — Scripted one-shot prompts are typically cheaper than interactive sessions for simple operations.

Common Workflows That Just Work

Here are the patterns I use most after finishing the course:

The Morning Standup:

/clear
What changed in this repo in the last 24 hours? Summarize the recent commits and any open PRs.

The Bug Fix Flow:

There's a bug where users can submit the form without filling in required fields.
Find where form validation happens, fix it, write a test, and run the test suite.

The PR Prep:

/review

Fix whatever it flags, then:

Write a clear commit message and create a PR description summarizing these changes.

The "I Just Joined This Project" Flow:

/init
Explain the architecture of this project. What are the main modules,
how do they connect, and where should I look first?

What I Wish I Knew Before Starting

A few things that would have saved me time:

CLAUDE.md is everything. Invest thirty minutes writing a good one. It pays dividends in every single session.
You don't need to be precise with prompts. Claude Code is remarkably good at figuring out what you mean. "Make the login page look nicer" actually works.
Let it run commands. The instinct is to do everything yourself and just ask Claude for code snippets. Resist that. Let it run your tests, read your logs, check your git status. That's where the agentic magic happens.
Clear your context aggressively. The number one mistake beginners make is letting a session run too long with too much accumulated context.
MCP servers are worth the setup time. Even one or two well-configured MCP integrations dramatically expand what Claude can do for you.

Getting Started Today

Here's your five-minute quickstart:

npm install -g @anthropic-ai/claude-code
cd your-project
claude
/init

Then just start talking to it. Ask it to explain your codebase. Ask it to fix something. Ask it to write a test. The barrier to entry is genuinely low — the hard part isn't learning the tool, it's unlearning the habit of doing everything yourself.

Claude Code isn't going to replace you. But a developer who knows how to use Claude Code well is going to be significantly more productive than one who doesn't. The course made that clear, and a week of daily use has made it obvious.

The terminal just got a whole lot more interesting.

Heya! Check this out if you wanna get started with making AI Projects.

Jayesh Padhiar — Thu, 28 Aug 2025 12:50:06 +0000

Jayesh Padhiar

Aug 28 '25

Getting Started with OpenAI APIs: A Complete Developer's Guide

Comments

9 min read

Getting Started with OpenAI APIs: A Complete Developer's Guide

Jayesh Padhiar — Thu, 28 Aug 2025 07:11:36 +0000

Building powerful AI applications with OpenAI's Responses API

Introduction

Artificial Intelligence has revolutionized how we build applications, and OpenAI's APIs are at the forefront of this transformation. Whether you're a seasoned developer or just starting your AI journey, this guide will walk you through everything you need to know to get started with OpenAI's powerful APIs.

In this comprehensive tutorial, we'll explore:

Setting up your development environment
Understanding OpenAI's Responses API
Building practical examples from basic text generation to advanced features
Working with images, files, web search, and custom functions
Multi-agent workflows and intelligent routing
Best practices and real-world applications

By the end of this guide, you'll have a solid foundation to build your own AI-powered applications.

Project Setup

Prerequisites

Before we dive in, make sure you have:

Node.js installed (version 14 or higher)
An OpenAI API key (get one from platform.openai.com)
Basic JavaScript knowledge

Initial Setup

Let's start by creating our project structure:

mkdir openai-api-sandbox
cd openai-api-sandbox
npm init -y

Installing Dependencies

We'll need two main packages:

npm install openai dotenv

openai: The official OpenAI JavaScript library
dotenv: For managing environment variables securely

Project Structure

Here's our final project structure:

openai-api-sandbox/
├── examples/
│   └── 01-basics.js
├── index.js
├── package.json
├── .env
└── README.md

Environment Configuration

Create a .env file in your project root:

OPENAI_API_KEY=your_openai_api_key_here

Important: Never commit your .env file to version control. Add it to your .gitignore:

.env
node_modules/

Package.json Configuration

Update your package.json to use ES modules:

{
  "name": "openai-api-sandbox",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "dotenv": "^17.2.1",
    "openai": "^5.11.0"
  }
}

Basic Setup Code

Create index.js as our entry point:

import './examples/01-basics.js';

Understanding OpenAI's Responses API

OpenAI's Responses API is a powerful interface that allows you to interact with various AI models. Unlike the traditional Chat Completions API, the Responses API provides a more flexible structure for handling different types of inputs and outputs.

Key Concepts

Model Selection: Choose from various models like gpt-4o-mini, gpt-4o, etc.
Input Formats: Support for text, images, files, and structured messages
Instructions: Provide context and behavior guidelines
Tools: Extend functionality with image generation, web search, and custom functions
Streaming: Real-time response generation

Example 1: Basic Text Responses

Let's start with the simplest example - generating text responses.

Simple String Input

const basicResponse = async () => {
    const response = await openai.responses.create({
        model: 'gpt-4o-mini',
        instructions: 'You are a helpful assistant that ends every response with a joke.',
        input: 'Hi, how are you?'
    });
    console.log('Response 1:', response.output_text);
}

Expected Output:

Response 1: Hello! I'm doing great, thank you for asking! I'm here and ready to help you with whatever you need. 

Why don't scientists trust atoms? Because they make up everything! 😄

Structured Message Input

const response2 = await openai.responses.create({
    model: 'gpt-4o-mini',
    input: [
        {
            role: 'developer',
            content: 'You are a helpful assistant that ends every response with a joke.'
        },
        {
            role: 'user',
            content: 'Hi, how are you?'
        }
    ]
});

Key Differences:

String input: Quick and simple for basic interactions
Structured input: More control over conversation flow and context

The developer role acts like a system message, providing instructions that guide the AI's behavior throughout the conversation.

Example 2: Streaming Responses

For longer responses, streaming provides a better user experience by showing content as it's generated.

const streamResponse = async () => {
    const stream = await openai.responses.create({
        model: 'gpt-4o',
        input: 'give a brief of the history of the internet',
        stream: true
    });

    for await (const chunk of stream) {
        process.stdout.write(chunk.delta ?? '');
    }
}

What happens:

The response appears word by word in real-time
Much better user experience for long-form content
Lower perceived latency

Use cases:

Chatbots and conversational interfaces
Content generation tools
Real-time assistance applications

Example 3: Image Analysis

OpenAI's vision capabilities allow you to analyze and understand images.

const imageAnalysis = async () => {
    const imageurl = 'https://upload.wikimedia.org/wikipedia/commons/3/3d/Lionel_Messi_NE_Revolution_Inter_Miami_7.9.25-055.jpg';

    const response = await openai.responses.create({
        model: 'gpt-4o-mini',
        input: [
            {
                role: 'user',
                content: [
                    {
                        type: 'input_text',
                        text: 'What is this image? What is the name of the player in the image? What is the name of the team in the image?'
                    },
                    {
                        type: 'input_image',
                        image_url: imageurl,
                        detail: 'low'
                    }
                ]
            }
        ]
    });
    console.log(response.output_text);
}

Expected Output:

This image shows Lionel Messi, one of the greatest soccer players of all time. He's wearing an Inter Miami CF jersey, which is the MLS team he currently plays for. The image appears to be from a match where Inter Miami is playing, and you can see Messi in his characteristic playing style on the field.

Detail Levels:

low: Faster processing, good for general analysis
high: More detailed analysis, better for complex images
auto: Let OpenAI choose based on the image

Example 4: Image Generation

Generate images directly through the API using AI tools.

const imageGeneration = async () => {
    const response = await openai.responses.create({
        model: 'gpt-4.1',
        input: 'generate a photo of an engineering team sitting and having lunch',
        tools: [
            {
                type: 'image_generation',
                quality: 'low'
            }
        ]
    });

    // Save the image to a file
    const imageData = response.output
        .filter((output) => output.type === "image_generation_call")
        .map((output) => output.result);

    if (imageData.length > 0) {
        const imageBase64 = imageData[0];
        fs.writeFileSync("image.png", Buffer.from(imageBase64, "base64"));
        console.log("Image saved as image.png");
    }
}

What this does:

Requests image generation through the tools parameter
Filters the response to find image generation results
Converts base64 data to a PNG file
Saves it locally

Quality Options:

low: Faster generation, lower quality
high: Better quality, slower generation

Example 5: File Analysis

Analyze documents, PDFs, and other files directly.

const fileAnalysis = async () => {
    const response = await openai.responses.create({
        model: 'gpt-4o-mini',
        input: [
            {
                role: 'user',
                content: [
                    {
                        type: 'input_text',
                        text: 'Analyze the following file and give me a brief of the person'
                    },
                    {
                        type: 'input_file',
                        file_url: 'https://jayeshpadhiar.com/files/Jayesh_Padhiar_Resume.pdf'
                    }
                ]
            }
        ],
    });
    console.log(response.output_text);
}

Supported file types:

PDFs
Text files
Images
Spreadsheets (CSV, Excel)
And more

Use cases:

Resume analysis
Document summarization
Content extraction
Data analysis

Example 6: Web Search Integration

Access real-time information from the web.

const webSearch = async () => {
    const response = await openai.responses.create({
        model: 'gpt-4o-mini',
        input: 'whats the news on supreme court and dogs',
        tools: [
            {
                type: 'web_search_preview',
            }
        ]
    });
    console.log(response.output_text);
}

What this enables:

Real-time information retrieval
Current events and news
Up-to-date data and statistics
Fact-checking and verification

Expected Output:

Based on recent web search results, here are some recent news items about the Supreme Court and dogs:

1. There was a recent case involving service dogs and accessibility rights...
2. A Supreme Court justice made comments about pet ownership during a hearing...
3. Legal discussions about animal rights have been ongoing...

[The AI provides current, factual information from web sources]

Example 7: Custom Functions (Advanced)

The most powerful feature - creating custom tools that the AI can use.

const customFunction = async () => {
    const tools = [{
        type: 'function',
        name: 'get_weather',
        description: "'Get the latest weather of the given location and return the temperature in celsius and end the response with a joke',"
        parameters: {
            type: 'object',
            properties: {
                location: {
                    type: 'string',
                    description: 'The location to get the weather for'
                }
            },
        },
    }];

    let input = [{
        role: 'user',
        content: 'whats the weather in navi mumbai'
    }];

    let response = await openai.responses.create({
        model: 'gpt-4o-mini',
        input,
        tools,
        tool_choice: 'auto'
    });

    // Add the AI's response to the conversation
    input = input.concat(response.output);

    // Get the function call details
    const functionCall = response.output.find(output => output.type === 'function_call');

    // Your custom function implementation
    const getWeather = async (location) => {
        // In a real app, you'd call a weather API here
        return {
            location,
            temperature: 25,
            weather: 'sunny',
            joke: 'Why did the computer scientist get a cold? Because it had too many bugs!'
        }
    };

    const result = await getWeather('navi mumbai');

    // Add the function result back to the conversation
    input.push({
        type: 'function_call_output',
        call_id: functionCall.call_id,
        output: JSON.stringify(result)
    });

    // Get the final response
    response = await openai.responses.create({
        model: 'gpt-4o-mini',
        input,
        tools,
        instructions: 'Give the final response here',
    });

    console.log(response.output_text);
}

Expected Output:

The weather in Navi Mumbai is currently sunny with a temperature of 25°C. It's a beautiful day!

Why did the computer scientist get a cold? Because it had too many bugs! 😄

Understanding the Function Flow

Define the function: Specify name, description, and parameters
AI decides to call it: Based on user input and function description
Execute your function: Run your custom logic
Return results: Feed the results back to the AI
Get final response: AI processes the results and responds to the user

Tool Choice Options

auto: AI decides when to use tools
required: AI must use a tool
none: AI cannot use tools

Example 8: Multi-Agent Workflows (Advanced)

OpenAI's Agent framework allows you to create sophisticated multi-agent systems where different agents can handle different tasks and hand off to each other.

import {Agent, run} from '@openai/agents'

const agentFlow = async () => {
    const spanishAgent = new Agent({
        name: 'spanishAgent',
        instructions: 'you are an agent that only speaks spanish. start your response with "Hola soy un agente de espanol"',
    });

    const englishAgent = new Agent({
        name: 'englishAgent',
        instructions: 'you are an agent that only speaks english. start your response with "Hello I am an english agent"',
    });

    const germanyAgent = new Agent({
        name: 'germanAgent',
        instructions: 'you are an agent that only speaks german. start your response with "Hallo ich bin ein deutscher agent"',
    });

    const langAgent = new Agent({
        name: 'langAgent',
        instructions: 'you are an agent that takes input from the user and translates it to the language of the agent that is speaking',
        handoffs: [spanishAgent, englishAgent, germanyAgent]
    });

    const result = await run(langAgent, 'was machst du?');
    console.log(result.finalOutput);
}

Expected Output:

Hallo ich bin ein deutscher agent

Ich bin ein KI-Assistent, der dir bei verschiedenen Aufgaben helfen kann. Ich kann Fragen beantworten, Texte übersetzen, bei der Problemlösung helfen und vieles mehr. Was kann ich heute für dich tun?

Understanding Multi-Agent Systems

Agent Definition: Each agent has specific instructions and capabilities
Language Specialization: Agents are designed for specific languages or tasks
Handoff Mechanism: The main agent can delegate to specialized agents
Intelligent Routing: The system automatically determines which agent should handle the request

Key Benefits

Specialization: Each agent excels at specific tasks
Scalability: Easy to add new agents for different capabilities
Maintainability: Clear separation of concerns
Flexibility: Dynamic routing based on user input

Real-World Applications

Customer Support: Route queries to language-specific agents
Content Creation: Different agents for writing, editing, and translation
Technical Support: Specialized agents for different product areas
Educational Tools: Subject-specific tutoring agents

Complete Example Code

Here's the complete 01-basics.js file with all examples:

// this example explores the responses api of openai
import dotenv from 'dotenv';
import OpenAI from 'openai';
import fs from 'fs';

dotenv.config();

const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

// All the functions we've discussed above...
// [Include all the function code here]

// Run a specific example
basicResponse();

Running Your Examples

To test your setup:

node index.js

Or run specific examples by modifying the function call at the bottom of 01-basics.js.

Best Practices

1. Error Handling

Always wrap API calls in try-catch blocks:

const safeApiCall = async () => {
    try {
        const response = await openai.responses.create({
            model: 'gpt-4o-mini',
            input: 'Hello, world!'
        });
        console.log(response.output_text);
    } catch (error) {
        console.error('API Error:', error.message);
    }
};

2. Rate Limiting

Be mindful of API rate limits:

Start with smaller, cheaper models for testing
Implement retry logic with exponential backoff
Monitor your usage in the OpenAI dashboard

3. Cost Management

Use gpt-4o-mini for most tasks (cheaper and faster)
Use gpt-4o only when you need the extra capability
Set up billing alerts in your OpenAI account

4. Security

Never hardcode API keys
Use environment variables
Implement proper authentication in production apps
Validate and sanitize user inputs

Real-World Applications

Customer Support Chatbot

const customerSupport = async (userMessage) => {
    return await openai.responses.create({
        model: 'gpt-4o-mini',
        instructions: 'You are a helpful customer support agent. Be polite, professional, and try to solve problems efficiently.',
        input: userMessage
    });
};

Content Generation Tool

const generateBlogPost = async (topic, tone) => {
    return await openai.responses.create({
        model: 'gpt-4o',
        instructions: `Write a ${tone} blog post about ${topic}. Include an introduction, main points, and conclusion.`,
        input: `Create a comprehensive blog post about: ${topic}`
    });
};

Code Review Assistant

const reviewCode = async (codeSnippet) => {
    return await openai.responses.create({
        model: 'gpt-4o',
        instructions: 'You are a senior software engineer. Review this code for bugs, performance issues, and best practices.',
        input: `Review this code:\n\n${codeSnippet}`
    });
};

Common Challenges and Solutions

1. Token Limits

Problem: Responses get cut off or requests fail due to token limits.

Solution:

Break large inputs into smaller chunks
Use summarization for long documents
Choose appropriate models based on context length needs

2. Inconsistent Outputs

Problem: AI responses vary too much between runs.

Solution:

Use more specific instructions
Provide examples in your prompts
Adjust temperature settings (lower = more consistent)

3. Function Calling Issues

Problem: Custom functions not being called correctly.

Solution:

Improve function descriptions
Provide clear parameter definitions
Test with simple examples first

Next Steps

Now that you've mastered the basics, here are some areas to explore:

1. Advanced Features

Fine-tuning models for specific use cases
Working with embeddings for semantic search
Implementing RAG (Retrieval-Augmented Generation)

2. Production Considerations

Building robust error handling
Implementing caching strategies
Setting up monitoring and logging

3. Integration Ideas

Build a Slack bot
Create a web application with React/Vue
Integrate with databases and external APIs

4. Learning Resources

Conclusion

OpenAI's APIs open up incredible possibilities for building intelligent applications. From simple text generation to complex multimodal interactions, you now have the foundation to create powerful AI-driven solutions.

The examples we've covered demonstrate the versatility of the Responses API:

Basic text generation and conversation
Real-time streaming responses
Image analysis and generation
File processing and analysis
Web search integration
Custom function calling
Multi-agent workflows and intelligent routing

Remember to start small, experiment frequently, and always keep user experience in mind. The AI landscape is evolving rapidly, and staying curious and experimental will serve you well.

Happy coding! 🚀

Want to see more AI development tutorials? Follow me on Medium for more in-depth guides and real-world projects.

Repository

You can find the complete code for this tutorial on GitHub: openai-api-sandbox

Feel free to fork, experiment, and build upon these examples!