AI For Developers With GitHub Copilot, Cursor AI & ChatGPT

Explore GitHub Copilot as an upgrade for IDEs like Visual Studio Code, covering its core features, chat and agentic capabilities, and practical configuration options for developers.

Explore how GitHub Copilot functions as an AI-powered IDE extension in Visual Studio Code, offering code completions, generation, AI chat and agents, with paid subscriptions and sign-in requirements.

Discover how GitHub Copilot delivers AI-powered autocompletion, next-edit suggestions, and variant options for developers, and learn to tailor these prompts with comments and per-file controls.

Open the command palette, select 'change completions model,' and choose a different AI model for Copilot completions to potentially improve results.

Explore how GitHub Copilot’s integrated AI chat speeds coding, with quick access via the top button and flexible placement, including sidebar, detached window, or editor-area chat.

Master inline chat and quick chat to request targeted code changes, preview AI suggestions, and apply edits within your editor using model selection and context management.

Configure Copilot models and features at the account level by enabling or disabling specific models, team or personal permissions, and preview options in VS Code.

Configure GitHub Copilot in your code editor through local or global settings to fine-tune its behavior. Review VS Code release notes for new features and settings.

Learn ask mode in GitHub Copilot’s chat in VS Code to plan features with project context and AI models, then switch to agent, edit, or plan mode as needed.

Discover agent mode, where the assistant creates directories and edits files, autonomously works on your codebase, previews changes, and uses file or block reviews with permissions for virtual environments.

Create and configure custom agents, set tools and permissions, and enable agent collaboration to read code, perform web search, gather docs, evaluate Faker best practices, and edit files.

Configure and customize chat sessions and agents by managing prompt files, chat instructions, MCP servers, toolsets, and chat settings in VS Code.

Learn to safely manage AI outputs by using checkpoints and Git version control to undo changes, restore states, and edit and resubmit prompts, while recognizing AI results are not deterministic.

Craft specific prompts and provide useful context to guide AI agents. Build prompts session by session, focusing on one feature at a time to improve results.

Craft prompts with precise context to guide agent mode, using plan mode, follow-up questions, and explicit references to files like main.py to influence outcomes. Explore adding context from files, docs, and editor selections, then test and refine generated code with permission prompts and optional follow-up edits.

Learn how background and cloud agents work in AI for developers with GitHub Copilot, including work trees, permissions, and how cloud agents submit pull requests.

Create reusable prompt files via the gear menu, store them with metadata, and apply them through commands to an ask agent to analyze code like main.py for Python best practices.

Explore built-in commands via the slash feature, including the prompt file command, search, fix, and tests; point at main.py for DAI to write automated fixes or tests, and use help.

Explore smart actions from GitHub Copilot, including code-based suggestions and selection-driven enhancements, and use ai to generate commit messages in Visual Studio Code.

Generate chat instructions from your codebase to enforce coding style and patterns, store them locally or globally, and auto-load them to guide edits like main.py.

Understand how to use the agents.md special instructions file to set global and subfolder specific guidelines for coding agents, including GitHub Copilot, Cursor, and Python style rules.

Learn how to add and configure agent skills in GitHub Copilot, using a skills subfolder and per-skill skill.md files that load prompts and descriptions on demand.

Configure Visual Studio Code with MCP servers to empower AI agents with Python tools, documentation browsing via context7, and browser testing using Playwright, while managing context loading.

Explore how GitHub Copilot, the veteran AI assistant for developers, provides suggestions, completions, chat, and Copilot extensions. Learn tips on using tab key and other features efficiently.

Explore GitHub Copilot, an AI-powered IDE extension that delivers smart code completion and the ability to generate entire code blocks inside the IDE, with code-aware chat and paid subscription.

Explore how to install and set up GitHub Copilot in Visual Studio Code, sign into GitHub, and install Copilot extensions, with free and pro plan options and a feature overview.

Install and log into GitHub Copilot in your IDE, then explore multiple non-deterministic code suggestions as you type to build a convertF2 function for Fahrenheit to Celsius.

Discover how next edit suggestions from GitHub Copilot in Visual Studio Code can predict your next edits, including enabling the preview setting, and learn to accept them to boost productivity.

Learn to guide GitHub Copilot with descriptive comments to generate flexible temperature conversion functions (Fahrenheit or Celsius) and explore multiple code completions to speed up development.

Learn to build a Python script that backs up and restores an SQLite database, using Copilot suggestions and a simple menu to manage one backup and one active database.

Explore how to use GitHub Copilot's inline chat to add error handling to a database backup script, generating and refining code and producing a user-friendly error message.

Configure GitHub Copilot by adjusting workspace or user settings, including language enablement and chat options. Enable temporal context and a copilot-instructions.md file to refine cross-file suggestions as settings evolve.

Explore GitHub Copilot's code actions to get smart, code-specific suggestions via sparkles, inline chat, and fixes for errors directly in Visual Studio Code.

Open the sidebar chat to tackle complex code tasks and ask for optimization and error handling; receive explanations and apply editor changes with code suggestions.

Learn to add context with references and shortcuts in GitHub Copilot Chat, enabling smarter code creation by referencing the code base, specific files like dbBackup, symbols, or the entire file.

Add participants with the at symbol to enrich chat context across chat sidebar and inline chat, reference files or code bases, pull in VS Code, terminal, workspace, GitHub context.

Learn how AI-powered terminal chat helps developers generate exact commands, insert them into the terminal, and use inline terminal chat to run Python or Git tasks safely, boosting efficiency.

Explore GitHub Copilot slash commands like explain, fix, and tests to analyze and improve selected code, using terminal and inline chat, and view the explanation in chat.

Discover Copilot edits mode for multi-file editing in GitHub Copilot, which analyzes existing files, suggests creating new ones, and automatically edits multiple files to fulfill a prompt.

Explore slash tests to generate unit tests for selected code sections, using AI to write and propose tests, then save them in a separate test file for a project.

Use the /new command to create a new node.js project with express, preview a suggested project structure, and generate files in a chosen folder via GitHub Copilot chat.

Learn prompt engineering essentials for coding with GitHub Copilot Chat, focusing on specificity, clear intent, concise context, and task splitting to improve AI results.

Use specific prompts and added context to guide GitHub Copilot and chat, generating restaurant table reservation routes in tables.js and updating app.js for cohesive AI code generation.

Learn to validate reservation input with GitHub Copilot Sidebar Chat by crafting specific prompts and enforcing rules for 1–6 people, 5:00–11:00 every 30 minutes, and today or later.

Practice effective iteration by balancing AI-generated code with targeted manual edits, knowing when to migrate to esm imports and when a simple change should be done manually.

Explore GitHub Copilot extensions to extend Copilot with Docker knowledge, generating Docker files and Docker compose, and install VS Code extensions via chat to add new context for Copilot chats.

Explore Cursor, the popular ai-powered ide, and identify its core features, including auto suggestions, tab completions, and chat mode for generating complex code with AI.

Cursor is an AI-powered integrated development environment, a fork of Visual Studio Code, with code completion, code generation, and a built-in AI chat and agents.

Explore Cursor pricing from free to pro and ultra, unlocking more prompts and tasks in top-tier models, while Cursor does not train on your data.

Explore Cursor editor mode, switch to agents mode from the top-left, and review settings for AI models, chat features, tab completion, and privacy controls in the VS Code–like UI.

Explore Cursor’s tab feature that predicts multiple lines and makes complex edits across files, letting you fly through your code while staying in control—faster than Copilot.

Discover how Cursor's tab completion accelerates code edits by generating context-aware suggestions, including GitHub Copilot insights, for opening files, renaming variables, and writing or reading files via keyboard shortcuts.

Learn how tab-completion settings in the cursor integrate ai-assisted features, enabling or disabling options, partial accepts, and comment suggestions, with examples in TypeScript and Python.

Use comment-based prompting to steer the tab completion, similar to GitHub Copilot; write a descriptive comment like 'append to file' and let the tab suggest and generate the corresponding code.

Use Cursor's inline chat to edit code by highlighting segments and previewing changes. Configure AI models in settings and refactor functions to use Python's input for user prompts.

Learn how the inline explanations feature enables quick questions to explain code, switch between quick question mode and edit full file mode, and highlight code to get the AI's explanation.

Explore inline chats for full-file edits, switching between selection edits and full-file checks, renaming functions across a file, and reviewing line-by-line or all-at-once changes.

Use Visual Studio Code's integrated terminal inline chat to generate git commands, set a user name and email, and search files by criteria, then review and press enter to execute.

Cursor's ai agent in the sidebar chat to query and generate code, leveraging code-base awareness from indexing, with flexible chats and configurable default mode and context.

Select and enable AI models, add new ones, and switch deep think mode or max mode to control context and token usage in Cursor.

Explore ask mode in the code assistant to ask questions about your code and receive explanations and improvement suggestions, with copy or duplicate chat options.

Agent mode actively edits your code while analyzing it, shows changes, and lets you undo or tweak edits through a guided, multi-file menu.

We introduce background mode, running tasks in the cloud via a GitHub repository and pull requests, and plan mode, gathering information across code base before switching to agent mode.

Use cursor checkpoints to revert to a prior code state in agent mode, without commits or AI undo costs. Click per-message checkpoint to undo, restore, or reapply changes as needed.

Queue messages to an AI agent, stop edits when needed, and safely add prompts without interrupting work. Rename functions and complete both original and updated tasks by queuing.

Continue exploring Cursor's advanced features and prompt-writing strategies to sharpen your skills, and anticipate deeper Cursor coverage in the next section.

Explore Cursor agents and their agentic capabilities, mastering context and prompt engineering, configuring Cursor with rules and agent rules, and using tools and MCP servers for advanced workflows.

Learn to configure and run agents in Cursor AI, switching among ask, agent, and plan modes, and choose local or remote execution while exploring agent settings.

Develop an AI-powered utility that reads markdown blog posts and generates optimized tweets and X posts, using a Python project managed by UV and Cursor Agents.

Learn how Cursor switches between plan mode and agent mode to tackle tasks, build and edit a plan, then generate, review, and test code from Markdown files in main.py.

Learn how to use the OpenAI API with GPT-5 to generate an optimized X post from markdown content, manage plan and agent modes, and integrate the OpenAI package.

Learn how to migrate to the OpenAI responses API and teach Cursor to use a new context window, add file references, and leverage web search to craft more effective prompts.

Load an OpenAI api key as an environment variable from a .env file using the python-dotenv module, then run main.pwa to produce an X post, and don't outsource to ai.

Learn ask mode to discuss code with AI without editing, get explanations and best-practice improvements, and switch modes to continue editing the file.

Explore Cursor's agent layout in a ReactJS project to build a browser-based to-do manager. Use plan and review modes to modify App.tsx and CSS and run the local dev server.

Revert AI agent changes by editing past messages, using back and revert options, and re-running updated instructions to enforce a code style (function keyword vs arrow functions) while testing results.

use cursor rules and agents.md to enforce react code style on .tsx files, with rules in .cursor/rules or agents.md, moving to-do list logic from app.tsx to todo-list.tsx.

Showcase how Cursor.AI uses tools and browser previews to add and verify animations in a to-do list, installing motion and testing UI changes.

Explore model context protocol (MCP) and how Cursor leverages MCP servers like Context7 to add tools and discover documentation. Learn the steps to install and use MCP servers in Cursor.

Explore how Cursor stores memories to learn your preferences and uses commands like Smart Docs with Context7 MCP to fetch documentation, through agent mode and forward slash shortcuts.

Learn to use the .cursorignore file to exclude sensitive files from cursor, like a git ignore, including .env environment variables and .venv, noting that .env is ignored by default.

Dive into Cursor AI, an AI-powered IDE that helps you write code with built-in tools, suggestions, and auto-completion. Explore its built-in chat and the Composer feature to speed up development.

Learn how Cursor AI integrates AI into an IDE to boost developer productivity with smart code completion, code generation, and code-aware chat, as a VS Code fork with AI features.

Explore Cursor's key features, learn how to use them effectively, and apply prompt engineering techniques alongside GitHub Copilot, including chat interactions and practical examples.

Discover cursor's auto-suggestions in a vscode-like editor, guiding a python writer.py to write and read files. Compare cursor to GitHub Copilot and note its aggressive, powerful completions.

Discover Cursor's AI-driven code completion that predicts edits across the codebase and lets you accept changes by tab, contrasting with Copilot's approach and moving through a file quickly.

Fix code on the fly with Cursor's smart completion, adding keywords, parameters, and functions to parse input and output. Use tab to accept suggestions and speed development beyond GitHub Copilot.

Learn to use comments as prompts to guide Cursor’s code generation, overwrite undesired AI suggestions with real code, and steer the AI via mindful prompts, user input handling, and loops.

Cursor helps you debug terminal errors by pasting the output into a chat, generating a code snippet, and applying fixes like renaming input to user input.

Discover Cursor's inline chat for in-editor code edits, including error handling, two kinds of chat, optional web search, AI models, and the ability to accept or reject changes.

Explore Cursor's docs integration to generate code that serves files from a public folder statically in a Node.js Express app, using the Express documentation for accurate prompts.

Learn to generate terminal commands with the inline-chat, using natural language to describe actions like git init, then reject, press escape to accept and close, or run to execute.

Learn to use quick question mode to explain selected code, ask what this code does, clarify things like extended false, and perform web searches via cursor, without generating code.

Explore using the external sidebar chat window with Cursor and GitHub Copilot to add multi-file context and generate code, including a put route to edit a reservation.

Use cursor's composer mode (agent mode) to perform multi-file edits, add authentication with sqlite and JWT, create routes and models, and review changes with a diff view.

Explore Cursor settings to tailor appearance and features. Enable auto-run mode in agent mode to auto-execute commands, but remember the risks and that some commands can be denied.

Explore the model context protocol servers (MCP) and how the GitHub MCP server extends Cursor by enabling actions like creating branches and repositories through composer mode.

Discover how Cursor can generate tests, explain code, and fix error messages alongside GitHub Copilot, with ongoing development. Experience Cursor in action in a demo app.

Explore when to use external AI services like ChatGPT, Cloud, or Google Gemini alongside integrated tools like GitHub Copilot and Cursor, and learn asset generation with MidJourney for development.

Explore when to use ChatGPT for coding tasks versus in-editor AI tools like GitHub Copilot and Cursor IDE, and why browser ChatGPT may still be useful for certain workflows.

Plan a node.js and express rest api with signup, login, authentication, authorization, and event creation, registration, update, and deletion, guided by ai chatbots in the browser.

Explore how external AI services aid development research, comparing authentication options beyond JWT, including third-party authentication services, and noting AI responses should be evaluated for potential hallucinations.

Use AI for asset generation with ChatGPT to produce icons and dummy images for development, while addressing copyright, legal restrictions, and technical limits.

Master prompt engineering across chat and code tools by writing specific, contextual prompts, using examples, splitting complex tasks into steps, and applying ask-before-answer prompting and RAG for better results.

Explore when to rely on external AI services in development, contrasting quick in-editor AI tools with the broader capabilities of browser-based chatbots like ChatGPT Cloud or Gemini.

Build a complete demo project to practice AI tools by creating a REST API with Node.js and Express, using Cursor, VS Code, and GitHub Copilot with your knowledge.

Plan to build rest api to create and share events, enable user authentication, registration for events, event management, and image upload, with access control for editing by only event creators.

Plan the application structure for a REST API using Node and Express, with user authentication, shared events, event creation and registration, and image uploads, guided by ChatGPT.

Set up a node.js rest API in Cursor AI by creating package.json with npm init -y and using app.js as the root entry, and add .env and folders.

Learn to scaffold user registration and login with Cursor Composer by creating a user model, sign-up and login routes, and linking to controllers, with JSON body parsing.

Apply follow-up feedback to convert code from common.js to esm exports, exporting plain functions like createUser and findUserByEmail, and switch imports accordingly.

Set up a SQLite database for a Node.js Express API using Cursor's sidebar chat, creating a database.js and updating user model and app.js to initialize and query users by email.

Refine a node app by moving database initialization after app.listen, and use port environment variables with a fallback to support /users route to the user controller and model.

Use inline chat to enhance signup validation with trimming, non-empty checks, regex email validation, and password minimum length, plus detecting existing emails in the database.

Test rest apis with Postman by posting to /users/signup on localhost:3000, sending email and password in json, and review the stored user data in database.sqlite, noting that passwords should be hashed.

Learn to securely hash and verify user passwords with bcrypt.js, switch to the async hash, add a verify credentials function, and integrate password handling into signup and login flows.

Use ai chat to debug an app, fix errors like verify user credentials being undefined by adding the proper import, and apply await to signup to obtain actual user data.

Add authentication to the REST API using JSON Web Tokens generated on signup or login, containing user id and email, verified with a secret key for protected routes.

Add event-specific routes in a routes file using GitHub Copilot inline chat, enabling creating, editing by id, and deleting events with ESM imports and exports.

Create, edit, and delete events by leveraging Copilot's sidebar chat to scaffold an events controller and models, and a SQLite-backed events table with title, description, address, and date.

Leverage Copilot and Cursor AI to create and export event functions (insert, update, delete, get by id, get all), wire them into the events controller and routes for clarity.

Fix route prefixes, wire events routes in app.js, and run the dev server to validate get and post calls, noting upcoming validation.

Learn to implement and test input validation for event creation using inline chat with Copilot, ensuring title, description, address, and date are valid and secured by JWT authentication.

Protect event routes by parsing the bearer token from authorization header with verifyToken and storing the user's id and email on the request, so only authenticated users can access them.

Protect create, update, and delete routes with an authenticate middleware and bearer token, while get routes remain public; obtain a token via login and use the authorization header.

Apply role-based authorization to ensure only the event creator can update or delete, via update and delete routes. Store the user ID with each event and validate it during edits.

Test authorization by using tokens from multiple users to create and edit events, ensuring only the creator can delete or modify their events.

Add post routes for registering and unregistering events with Copilot suggestions, and implement register and unregister controllers to manage event_id and user_id in a registrations table via authenticated requests.

Test and fix event registration and unregistration by moving database access to the model, using bearer token authorization on POST /event/{id}/register and DELETE /event/{id}/unregister, and validating responses.

Learn to integrate image upload into event creation and editing using the Multer package with local storage, saving images to public/images and storing the image filename in the database.

Learn to implement and test an image upload feature by extracting image keys, storing them in the database, and validating uploads with Postman and dummy images.

Install and register a CORS middleware to set headers for cross-origin requests, and use static middleware to serve public images so frontend apps can access them.

Explore frontend options for the API and use AI tools like GitHub Copilot, Cursor, and ChatGPT to generate frontend code and styling for web or mobile.