OpenAI Models

OpenAI's GPT and reasoning models power GitHub Copilot and countless production applications — fast, reliable, and excellent at code generation and reasoning.

Why Vibe Coders Use It

• Powers GitHub Copilot — the industry-standard IDE coding assistant
• Strong at code generation — GPT-4o is excellent for writing, debugging, and explaining code
• Reasoning models (o3, o4-mini) — step-by-step thinking for complex logic, math, and architecture decisions
• Multimodal (GPT-4o) — analyze code screenshots, UX designs, error traces
• Mature, widely-used — extensive documentation, examples, and integrations everywhere

Key Specs (GPT-4o vs Reasoning Models)

Getting Started

Choose Your Model

• GPT-4o — default choice for speed and capability
• o3 / o4-mini — when you need step-by-step reasoning or the task is very hard
• GPT-4o Mini — when cost matters and the task is straightforward

1. Create an Account & API Key

Sign up at platform.openai.com and generate an API key.

2. Set Your Environment Variable

OPENAI_API_KEY=sk-your-api-key-here

3. Install the SDK

npm install openai

4. Quick Chat Example (GPT-4o)

import OpenAI from 'openai';

const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You are a helpful coding assistant.' },
    { role: 'user', content: 'Refactor this function to use async/await' },
  ],
});

console.log(response.choices[0].message.content);

5. Using with AI SDK (Next.js, Recommended)

import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = streamText({
    model: openai('gpt-4o'),
    messages,
  });

  return result.toDataStreamResponse();
}

6. Reasoning Model Example (o3 for Hard Problems)

import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';

// Use o3 when standard models struggle
const { text } = await generateText({
  model: openai('o3'),
  prompt:
    'Design a distributed cache invalidation strategy for a multi-region system. Consider consistency guarantees and failure modes.',
  system: 'You are an expert systems architect.',
});

console.log(text);

Tool Use & Function Calling

GPT-4o is excellent at calling external tools. Here's a practical example:

const tools = [
  {
    type: 'function',
    function: {
      name: 'search_documentation',
      description: 'Search the project documentation',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string' },
        },
        required: ['query'],
      },
    },
  },
];

const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'How do I configure authentication?' }],
  tools,
});

// Handle tool calls in the response
if (response.choices[0].message.tool_calls) {
  for (const toolCall of response.choices[0].message.tool_calls) {
    // Execute tool and continue conversation
  }
}

When to Use Each Model

Use GPT-4o for everyday coding tasks, chat, content generation, and anything where speed matters.

Use o3 or o4-mini only when the task is genuinely hard (complex architecture, deep reasoning, math, logic puzzles). Reasoning models are slower and more expensive.

Use GPT-4o Mini for high-volume, simple tasks (classification, tagging, basic content gen) to reduce cost.

Comparison: GPT-4o vs Claude vs Gemini

Resources

• OpenAI API Documentation
• Chat Completions Guide
• Reasoning Models Guide
• AI SDK OpenAI Provider
• OpenAI Pricing
• See the full GPT profiles on LLMReference →