A Quick Look ChatGPT

If you’ve ever spent hours debugging code only to discover the fix was much simpler than you thought, you already know ChatGPT can be an excellent pair-programming buddy. This practical guide covers how to use ChatGPT effectively for software development: asking targeted questions, uploading files, scaffolding code, debugging, and choosing models or building custom GPTs for team workflows. What you’ll learn:

How to structure prompts and keep conversation context for iterative development.
Patterns for safe database connections and HTTP requests in Python.
When to use different ChatGPT models and Canvas for interactive editing.
How to design and use Custom GPTs for repeatable team tasks.

Quick overview:

The chat interface is clean and minimal: conversation history appears on the left and can be starred or continued.
You can upload files, ask incremental questions, and maintain context within a conversation.
ChatGPT is excellent for documentation, scaffolding, feature design, and debugging. For IDE-integrated, repository-aware assistance, consider tools like GitHub Copilot, Tabnine, or Blackbox AI.

Treat ChatGPT as a starting point. Read and understand generated code before copying it into production.

Best practices for using ChatGPT as a programming assistant

Provide a minimal reproducible example: include the smallest failing code, exact error messages, and environment details (Python version, OS, installed libs).
Break large problems into smaller steps and iterate: ask for a scaffold, then request tests or edge-case handling.
Use uploaded files or Canvas when you want the model to operate on real files or an editable surface.
Validate generated code with linters, unit tests, and static analysis before merging.

Example: Connecting to MySQL with Python

This concise, correct pattern shows how to connect to MySQL using mysql-connector-python, run queries safely, and ensure clean resource cleanup. Install the connector:

pip install mysql-connector-python

Python example:

import mysql.connector
from mysql.connector import Error

def connect_to_mysql(host: str, user: str, password: str, database: str):
    try:
        connection = mysql.connector.connect(
            host=host,
            user=user,
            password=password,
            database=database,
        )
        if connection.is_connected():
            print("Successfully connected to MySQL")
            return connection
    except Error as e:
        print(f"Error connecting to MySQL: {e}")
        return None

def query_database(connection, query: str):
    try:
        cursor = connection.cursor(dictionary=True)
        cursor.execute(query)
        rows = cursor.fetchall()
        return rows
    except Error as e:
        print(f"Error executing query: {e}")
        return None
    finally:
        if 'cursor' in locals():
            cursor.close()

# Usage
if __name__ == "__main__":
    conn = connect_to_mysql("localhost", "username", "password", "database_name")
    if conn:
        results = query_database(conn, "SELECT * FROM your_table_name;")
        print(results)
        if conn.is_connected():
            conn.close()
            print("MySQL connection is closed")

Notes:

Use cursor(dictionary=True) to return rows as dictionaries for named access.
Always close cursors and connections in finally or equivalent cleanup logic.
Never embed credentials in source control—use environment variables or secret managers.

Choosing the Right Model for Development Tasks

Selecting a model depends on your need for reasoning depth, latency, and cost. Use this table to compare common choices:

Model family	Best for	Notes
`gpt-3.5`	General programming tasks, low-cost experiments	Good for quick iterations and simple scaffolding.
`gpt-4o`	Strong general-purpose development tasks	Better reasoning and higher-quality outputs for design and refactors.
`gpt-4o` + Canvas (beta)	Interactive editing and collaborative prototyping	Provides an editable canvas for code/markup—great for one-file workflows.
`o1-preview`	Advanced reasoning and deep debugging	Useful when you need root cause analysis and step-through debugging.
`o1-mini`	Faster, smaller reasoning	Tradeoff: speed over depth for quick checks or CI tasks.

Choose the model that balances latency, cost, and the depth of reasoning you need. For repository-aware changes, prefer IDE-integrated assistants or provide the relevant files to ChatGPT. Links and references:

Canvas: Interactive Editing of Files

Canvas (available with some gpt-4o variants) provides a running, editable surface where the model can output and modify files directly. It’s ideal for prototyping, single-file refactors, or collaborative edits. Example — HTML boilerplate with CSS and JavaScript:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <meta http-equiv="X-UA-Compatible" content="ie=edge"/>
  <title>Boilerplate Page</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      background-color: #f0f0f0;
      color: #333;
      margin: 0;
      padding: 0;
    }

    header {
      background-color: #4CAF50;
      color: white;
      padding: 15px;
      text-align: center;
    }

    main {
      padding: 20px;
    }

    button {
      background-color: #4CAF50;
      color: white;
      border: none;
      padding: 10px 20px;
      cursor: pointer;
      font-size: 16px;
    }

    button:hover {
      background-color: #45a049;
    }

    /* Mobile-friendly styles */
    @media (max-width: 600px) {
      header {
        font-size: 1.5em;
        padding: 10px;
      }
      main {
        padding: 10px;
      }
      button {
        padding: 8px 16px;
        font-size: 14px;
      }
    }
  </style>
</head>
<body>
  <header>
    <h1>Welcome to the Boilerplate Page</h1>
  </header>
  <main>
    <p>This is a simple HTML boilerplate including CSS and JavaScript/TypeScript.</p>
    <button id="actionButton">Click Me!</button>
    <p id="message"></p>
  </main>

  <script type="module">
    const actionButton = document.getElementById("actionButton");
    const messageElement = document.getElementById("message");

    actionButton?.addEventListener("click", () => {
      alert("Hello!");
      if (messageElement) {
        messageElement.textContent = "Button clicked! Hello, World!";
      }
    });
  </script>
</body>
</html>

When to use Canvas vs IDE assistants:

Canvas: fast, focused edits on one or a few files and interactive mockups.
IDE assistants (Copilot, Tabnine): repository-aware changes, refactors spanning many files, and tests aligned to your codebase.

Working with Custom GPTs

Custom GPTs let you embed domain knowledge, coding standards, and helper commands into a tailored assistant. They’re useful for automating routine review tasks, enforcing style rules, or accelerating onboarding. Example command styles for a Custom GPT:

/help(any_question?: string)
/fix(any: string)
/quick_fix(any: string)
/explain(any: string)
/review(any: string)
/search(any: string)
/read(urls: string[])

Custom GPTs can be trained with style guides, code examples, and rules (e.g., excerpts from Code Complete) so the assistant’s suggestions align with your team’s expectations.

Use custom GPTs to enforce code review heuristics, suggest refactorings, and provide tailored debugging guidance.

Example: Sending HTTP Requests with `requests` (Python)

Install:

pip install requests

Robust patterns for GET, POST, and file uploads, with timeouts and error handling:

import requests
import logging
from typing import Any, Dict, Optional

logging.basicConfig(level=logging.INFO)

def send_get_request(url: str, params: Optional[Dict[str, Any]] = None, timeout: int = 10):
    try:
        response = requests.get(url, params=params, timeout=timeout)
        response.raise_for_status()
        return response.json()  # or response.text if not JSON
    except requests.exceptions.RequestException as e:
        logging.error(f"GET request failed: {e}")
        return None

def send_post_request(url: str, payload: Dict[str, Any], timeout: int = 10):
    try:
        response = requests.post(url, json=payload, timeout=timeout)
        response.raise_for_status()
        if response.status_code == 201:
            logging.info("Data successfully created.")
        else:
            logging.info(f"Received status code: {response.status_code}")
        return response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"POST request failed: {e}")
        return None

def send_file_upload(url: str, file_path: str, timeout: int = 30):
    try:
        with open(file_path, "rb") as f:
            files = {"file": f}
            response = requests.post(url, files=files, timeout=timeout)
            response.raise_for_status()
            return response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"File upload failed: {e}")
        return None

Practical tips:

Always set a timeout to avoid hanging requests.
Use response.raise_for_status() to convert HTTP errors into exceptions.
Prefer logging over print() for production and visibility.
Validate and sanitize inputs before sending them.

Table: HTTP helper overview

Function	Purpose	Returns
`send_get_request`	GET with params and timeout	`dict` or `None`
`send_post_request`	POST JSON payload	`dict` or `None`
`send_file_upload`	Upload file in multipart/form-data	`dict` or `None`

Using Advanced Reasoning Models for Debugging

Models like o1-preview are optimized for stepping through code and identifying root causes. When you use them:

Share the full function or module and the failing test or error trace.
Ask the model to list likely failure modes, missing imports, or incorrect assumptions.
Request a proposed patch with tests or a diff.

Common improvements recommended by advanced models:

Verify imports and package versions.
Add explicit exception handling and edge-case checks.
Introduce timeouts, retries, and clear logging.
Add unit tests and CI-friendly assertions.

Custom GPT Example: Automated Code Review (CodeMonkey)

A Custom GPT trained on code-quality principles can output structured reviews with actionable suggestions:

Strengths (readability, modularity)
Weaknesses (missing exception handling, hard-coded values)
Actionable steps (use logging, add validation, improve error handling)

Example suggested improvements for a naive POST script:

Wrap request calls in try/except.
Use response.raise_for_status() and explicit status checks.
Replace prints with logging.
Return structured data or None on failure.

Suggested improved snippet (example):

import logging
import requests
from typing import Any, Dict, Optional

logging.basicConfig(level=logging.INFO)

def send_post_request_with_handling(url: str, payload: Dict[str, Any], timeout: int = 10) -> Optional[Dict[str, Any]]:
    try:
        response = requests.post(url, json=payload, timeout=timeout)
        response.raise_for_status()
        if response.status_code == 201:
            logging.info("Data successfully created.")
            return response.json()
        else:
            logging.warning(f"Unexpected status code: {response.status_code}")
            return response.json()
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred during POST request: {e}")
        return None

Final Recommendations and Workflow Tips

Use ChatGPT as a context-free brainstorming and explanation tool; validate and test everything it suggests.
For repository-aware suggestions or large-scale refactors, rely on IDE-integrated assistants or provide the specific files to ChatGPT or Canvas.
Build or adopt Custom GPTs for repetitive team rules, automated code reviews, or onboarding checklists.
Always use linters, unit tests, and peer reviews before merging generated changes.
Treat generated code as a starting point: improve error handling, observability, and security before deploying.

This lesson covered practical patterns for MySQL connections, HTTP requests, Canvas-based editing, model selection, and building custom assistants. Use these patterns to accelerate development while maintaining code quality and operational safety.

Course Introduction

Introduction to AI-Assisted Development

Planning Phase

Development Phase - Backend

Development Phase - Frontend

Project Completion

A Quick Look ChatGPT

Best practices for using ChatGPT as a programming assistant

Example: Connecting to MySQL with Python

Choosing the Right Model for Development Tasks

Canvas: Interactive Editing of Files

Working with Custom GPTs

Example: Sending HTTP Requests with `requests` (Python)

Using Advanced Reasoning Models for Debugging

Custom GPT Example: Automated Code Review (CodeMonkey)

Final Recommendations and Workflow Tips

Watch Video

​Best practices for using ChatGPT as a programming assistant

​Example: Connecting to MySQL with Python

​Choosing the Right Model for Development Tasks

​Canvas: Interactive Editing of Files

​Working with Custom GPTs

​Example: Sending HTTP Requests with requests (Python)

​Using Advanced Reasoning Models for Debugging

​Custom GPT Example: Automated Code Review (CodeMonkey)

​Final Recommendations and Workflow Tips

Watch Video

Best practices for using ChatGPT as a programming assistant

Example: Connecting to MySQL with Python

Choosing the Right Model for Development Tasks

Canvas: Interactive Editing of Files

Working with Custom GPTs

Example: Sending HTTP Requests with `requests` (Python)

Using Advanced Reasoning Models for Debugging

Custom GPT Example: Automated Code Review (CodeMonkey)

Final Recommendations and Workflow Tips