Chapter 5: Other Companion Tools

"The best tool is the one that fits your workflow."

Beyond Cursor and Claude Code, there's a growing ecosystem of AI coding tools. Each fills a different niche. This chapter covers ChatGPT Projects, Augment Code, and how to choose between them.

ChatGPT: The Conversationalist

ChatGPT isn't a coding-specific tool, but it's incredibly useful for software engineering work—especially for thinking, planning, and learning.

//ChatGPT Projects

ChatGPT's Projects feature helps you organize AI conversations around your work:

What Projects Give You:

Grouped conversations - Keep related chats together
Custom instructions per project - Different behavior for different work
File storage - Reference documents stay attached across chats
Memory - ChatGPT remembers context from previous conversations

//Setting Up a Coding Project

Step 1: Create the project

Click "New Project" in the ChatGPT sidebar
Name it descriptively: "Backend API Development" or "MyApp iOS"

Step 2: Add custom instructions

Example for a Python project:

You are helping me develop a Python FastAPI application.
- Use Python 3.11 features when appropriate
- Follow PEP 8 style guidelines
- Assume pytest for testing
- The database is PostgreSQL with SQLAlchemy
- Be concise and technical
- When showing code, include type hints

Step 3: Upload reference files

Include files the AI should know about:

README or architecture docs
Example code showing your patterns
API specifications
Database schemas

//When ChatGPT Shines

Planning and Architecture:

I'm building a notification system for our app. Users should be able to
receive notifications via email, push, and in-app. They should be able
to configure preferences per notification type.

Help me design the data model and API structure.

Learning New Technologies:

Explain how React Server Components work. I understand traditional
React but I'm new to the App Router.

Code Review Discussions:

Here's a function I wrote for rate limiting. What edge cases am I missing?
What would you improve?

[paste code]

Debugging Complex Issues:

I'm seeing intermittent 502 errors on my API. Here's my infrastructure:
- Node.js app behind Nginx
- Running in Docker on AWS ECS
- PostgreSQL on RDS

What should I check?

//ChatGPT Limitations for Coding

No file access - You have to copy-paste code
No execution - Can't run or test code
Context limits - Long conversations can lose early context
No codebase awareness - Doesn't know your actual project structure

//Best Practices

Separate projects by concern. "Backend API" and "Frontend UI" shouldn't be the same project.
Start fresh chats often. When a conversation gets long, start a new one in the same project.
Update instructions as you evolve. If you adopt a new pattern, add it to project instructions.
Use it for thinking, not typing. ChatGPT is better for planning than for generating code you'll paste directly.

Augment Code

Augment Code is an AI coding assistant that emphasizes codebase understanding and enterprise features.

//Key Features

Deep Codebase Indexing: Augment indexes your entire repository and understands relationships between files, functions, and modules.

Context-Aware Suggestions: Because it knows your codebase, suggestions follow your existing patterns automatically.

Team Knowledge: In enterprise settings, Augment can learn from your team's coding patterns and documentation.

IDE Integration: Works as a VS Code extension (and other IDEs), similar to Cursor.

//When to Consider Augment

Large codebases - The indexing helps with complex projects
Enterprise/team settings - Shared context across developers
Existing VS Code users - If you don't want to switch to Cursor
Compliance requirements - Enterprise security features

//Augment vs Cursor

Aspect	Augment	Cursor
Base editor	VS Code extension	Fork of VS Code
Codebase indexing	Strong focus	Good
Agentic features	Growing	Mature (Agent mode)
Team features	Enterprise focus	Individual focus
Pricing	Free tier + paid	Free tier + paid

GitHub Copilot

The original AI coding assistant. If you're already using it, here's how it compares:

//What Copilot Does Well

Inline completions - Fast, unobtrusive suggestions as you type
GitHub integration - Works seamlessly with GitHub features
Language support - Broad support for many languages
Stability - Mature, well-tested tool

//Copilot's Limitations

Less agentic - Primarily autocomplete, less autonomous task completion
Context window - Smaller than newer tools
No built-in chat - Copilot Chat is separate and less integrated

//When to Stick with Copilot

You're happy with autocomplete-style assistance
Deep GitHub integration matters (Copilot for PRs, etc.)
Your company already has Copilot licenses
You don't need agentic features

//When to Consider Switching

You want Agent mode (autonomous task completion)
You need better codebase understanding
You want more control over context (@ references)

Choosing the Right Tool

Here's a decision framework:

//For Writing/Editing Code

Use Cursor or Augment. They're built for this—IDE integration, file editing, codebase awareness.

//For Thinking and Planning

Use ChatGPT. Better for back-and-forth conversation without needing to edit files.

//For Terminal/Remote Work

Use Claude Code. No GUI needed, works anywhere you have a terminal.

//For Quick Inline Completions

GitHub Copilot is still solid for this if you don't need more.

//Tool Decision Matrix

Task	Best Tool
Write a new feature	Cursor / Augment
Debug with error messages	Cursor / Claude Code
Plan a system design	ChatGPT
Understand a new library	ChatGPT
Work on remote server	Claude Code
Quick automation script	Claude Code
Code review discussion	ChatGPT
Refactor across files	Cursor / Augment
Learn a new framework	ChatGPT
Fast autocomplete	Copilot
Explain existing code	Any

Making Tools Work Together

You don't have to pick one. Here's how they complement each other:

//Planning → Implementation

Start in ChatGPT to discuss and plan your approach
Move to Cursor to implement, with the plan as context
Use ChatGPT again if you hit a design decision

//Learning → Applying

Use ChatGPT to understand a new library or pattern
Open Cursor to apply what you learned in your code
Go back to ChatGPT if you need deeper explanation

//Local → Remote

Use Cursor for local development
Use Claude Code when SSH'd into a server
Back to Cursor for the next feature

//Example Workflow: New Feature

1. ChatGPT: "Help me design the data model for a
   notifications system"
   [Discuss options, make decisions]

2. Cursor: "Create the Notification model based on this design:
   [paste from ChatGPT]"
   [Cursor creates the model and migrations]

3. Cursor: "Now create the API endpoints for notifications"
   [Cursor builds the API]

4. Claude Code (on server): "Run the migrations and verify
   the new tables are created correctly"
   [Claude Code executes and verifies]

Setting Up Custom Instructions Everywhere

Consistency across tools helps. Here's a base template you can adapt:

//For ChatGPT Project Instructions

I'm a senior software engineer working on [PROJECT DESCRIPTION].

Tech stack:
- [Language/Framework]
- [Database]
- [Other key technologies]

When helping me:
- Be concise and technical
- Assume I understand programming concepts
- If suggesting code, follow [STYLE GUIDE]
- Ask clarifying questions if my request is ambiguous
- Point out potential issues or edge cases I might miss

//For Cursor Rules

You are helping me develop a [LANGUAGE] [FRAMEWORK] application.

Project patterns:
- [Pattern 1]
- [Pattern 2]

When writing code:
- Follow existing patterns in the codebase
- Include error handling
- Add TypeScript types (if applicable)
- Don't add unnecessary comments

//For Claude Code (CLAUDE.md)

# Project: [NAME]

## Overview
[Brief description]

## Tech Stack
- [Technologies]

## Structure
- [Key directories and their purposes]

## Commands
- [Common commands]

## Conventions
- [Coding conventions to follow]

Key Takeaways

ChatGPT is for thinking. Planning, learning, discussing—not direct code editing.
Augment competes with Cursor. Consider it if you want to stay in VS Code or need enterprise features.
Copilot is still useful for fast autocomplete if you don't need agentic features.
Tools complement each other. Use ChatGPT for planning, Cursor for implementation, Claude Code for terminal work.
Set up custom instructions in all tools. Consistency improves results across the board.
Don't force one tool to do everything. Use the right tool for the task.

Next: The 10 rules for productive AI-assisted development and your first week action plan.