IS 4010: Application Development with Artificial Intelligence

Week 02: AI copilots and comparison workflows

Brandon M. Greenwell

AI tools for programming

AI-assisted development is already here

• Today we’ll compare AI programming tools across the browser, editor, and terminal
• You’ll learn to work with AI as your pair programming partner
• We’ll compare the major players and find the right tool for each job
• By the end, you’ll understand how to “talk” to AI about code

Start with enthusiasm - this is genuinely exciting technology that will transform how students approach programming. Emphasize that we’re not replacing programming skills, but augmenting them.

Demo hook: Have three browser tabs open (Gemini, ChatGPT, Claude) and be ready to show the same prompt to all three for the live comparison.

Course motto

Augment, don’t automate!

• AI is your co-pilot, not your autopilot
• Think of AI as a brilliant but sometimes eccentric junior developer
• AI provides suggestions → You review, approve, and own the code
• Your job: Direct, verify, and integrate AI assistance
• Remember: The pilot is always responsible for the flight

This is the foundational philosophy for the entire course. Spend time here - students need to understand that they remain in control and responsible for all code they submit.

Use the pilot/co-pilot analogy throughout the course. It’s memorable and accurate.

What are AI programming tools?

• Code generation: Turn comments and prompts into working code
• Code explanation: Break down complex functions into plain English
• Debugging assistance: Help identify and fix errors
• Refactoring support: Improve code structure and style
• Learning accelerator: Get instant feedback and alternative approaches

Under the hood: LLMs

• Large Language Models (LLMs): AI systems trained on massive amounts of text from the internet
• Pattern recognition experts: They’ve learned patterns in human language and code
• Statistical language models: They generate likely continuations from the prompt and available context
• Not authoritative sources: Fluent answers can still be incomplete, outdated, or wrong
• Surprisingly good at code: Programming languages follow patterns, just like natural language

Keep this explanation practical: generated text is not evidence. Students should verify claims and run generated code.

Key analogies to use: - Autocomplete on steroids: Everyone understands phone predictive text - Pattern matching: Like learning to recognize handwriting, but for language/code patterns - Very sophisticated parrot: Can produce remarkably coherent text without true “understanding”

Important points: - LLMs were trained on billions of lines of code from GitHub and other sources - They learned that certain patterns appear together (if you write a function definition, a return statement usually follows) - This is why they’re good at code completion but can make subtle logical errors - They work the same way for Python, Rust, English, or any other language: it’s all just patterns in text

Set expectations: These tools can be useful, but their output requires human judgment and verification.

Three working surfaces

• Browser chat: General-purpose conversation and explanations (Gemini, ChatGPT, Claude, and others)
• Editor assistant: Contextual completion, chat, and edits with GitHub Copilot in VS Code
• CLI agents: Repository-aware work in the terminal with Copilot CLI and Antigravity CLI

Frame these as surfaces rather than permanent tool loyalties. The same model or provider may appear in more than one surface, but the context and workflow differ.

Ask students which surface fits a task they have already performed and why.

Browser-based AI assistants

Examples: Gemini, ChatGPT, and Claude are general-purpose assistants that can help with programming.

• Access varies - Free tiers, limits, and available models can change
• Programming support - Useful for Python, explanations, and debugging
• Different outputs - Compare responses against the same requirements and tests
• Web-based interfaces - Easy to access
• Useful for learning - Ask for explanations, examples, and review, then verify the result

Emphasize that these are general-purpose AI models, not specialized coding tools. They’re excellent for learning, explanations, and brainstorming, but they’re different from purpose-built code assistants.

Access, rate limits, and available models change. Confirm the current course options before class and offer an equivalent route if a student’s account differs.

Point out that we’re focusing on the web interfaces first - this is the easiest entry point for beginners.

Conversational coding

The CPTF framework for great prompts:

1. Context: “Here is my Python function…”
2. Persona: “Act as a senior software developer reviewing my code.”
3. Task: “Find any potential bugs and suggest improvements.”
4. Format: “Provide your answer as a numbered list.”

Prompt quality matters, but it is not the only factor. Model capability, repository context, tool access, and verification also affect the result.

Have a few examples ready: - Bad: “Make this better” - Good: “Act as a Python expert. Here’s my function that calculates fibonacci numbers. Explain how it works and suggest any performance improvements. Format your response with explanations and code examples.”

Five prompt patterns

1. Explain this code

"Explain this Python dictionary comprehension step by step:

{word: len(word) for word in text.split() if len(word) > 3}"

2. Generate boilerplate

"Write a Numpy-style docstring for this function that calculates the area of a circle given its radius."

3. Refactor for clarity

"Convert this for loop into a more Pythonic equivalent using list comprehension or built-in functions."

Walk through each pattern with a concrete example. Students will reuse these patterns throughout the course.

Emphasize that good prompts are specific and provide context. The AI needs to understand what you’re trying to accomplish.

Two more prompt patterns

4. Debug assistance

"I'm getting a 'TypeError: unsupported operand type(s)' on line 15. Here's my code... What's the likely cause and how do I fix it?"

5. Architecture advice

"I need to store student information (name, ID, grades). Should I use a list of dictionaries or create a Student class? Explain the pros and cons of each approach."

For pattern 4, require the exact error, the smallest relevant code, and what the student already tried. For pattern 5, ask for trade-offs and evidence instead of treating a role label as expertise.

Live demo: head-to-head comparison

Our challenge: Create a Python function that takes a filename and returns the number of lines in the file, handling potential FileNotFoundError exceptions.

Let’s give the exact same prompt to all three AIs:

“Write a Python function called count_lines that takes a filename as a parameter and returns the number of lines in the file. Handle the case where the file doesn’t exist by returning 0. Include a NumPy-style docstring.”

This is the highlight of the session! Have three browser tabs ready: 1. Gemini (gemini.google.com) 2. ChatGPT (chat.openai.com) 3. Claude (claude.ai)

Paste the exact same prompt into each and show the results side-by-side. Point out: - Different coding styles - Quality of docstrings - Error handling approaches - Explanation quality - Any unique insights each model provides

This demonstrates that models have different “personalities” and there’s no single “best” tool.

What did we learn?

• Different models, different strengths: Each AI has its own “personality”
• Quality varies: Same prompt can yield different code quality
• No single winner: The “best” AI depends on your specific task
• Explanation matters: Some models explain their reasoning better
• Style differences: Notice variations in variable naming, comments, structure

After the live demo, take a few minutes to discuss what students observed. Ask: - Which response did you prefer and why? - Did any approach surprise you? - What differences in coding style did you notice?

This reinforces that AI tools are aids to human judgment, not replacements for it.

Ethics and limitations

• AI can hallucinate: Models sometimes generate plausible-looking but incorrect code
• You own the code: Never submit code you don’t understand
• Privacy matters: Be cautious about sharing sensitive info
• Academic integrity: Document your AI usage in assignments
• Keep learning: AI should accelerate your learning, not replace it

This is critical. Students need to understand that AI is a powerful tool but requires human oversight.

Share examples of AI hallucinations if you have them - perhaps a function that looks correct but has subtle bugs, or advice that sounds authoritative but is outdated.

Emphasize the course AI policy: use AI freely, but understand everything you submit.

A quick note on docstrings

• Before our lab, we need to introduce a key concept: the docstring
• A docstring is a string literal, enclosed in triple quotes ("""), that occurs as the first statement in a module, function, class, or method definition
• Its purpose is to explain what the code does
• We are learning about them now because they are the primary way you will communicate your intent to AI assistants
• A good docstring leads to good AI-generated code
• In Lab 02 the docstrings are written for you. Each one states a contract, and your job is to make the function satisfy it
• You will write your own, in the fuller style this course uses, in Week 05

This bridges from the AI discussion to the practical lab work. Lab 02 is a guided Python preview, so students need only enough context to read a function and describe its intent.

Emphasize the connection: clear human communication (docstrings) leads to better AI assistance. This reinforces that AI tools respond to human intent and clarity.

Keep this at the one-line level. Lab 02 supplies three single-line docstrings as the contracts the agents implement against, so students only need to read one here. The NumPy format with Parameters and Returns sections is introduced in Week 05, where they first write their own.

Where this is heading

• In Lab 02 you will implement three small Python functions: make_greeting, is_even, and count_vowels
• Read every suggestion, run the provided tests, and revise the result instead of accepting code blindly
• This is a preview of Python and testing; formal Python instruction begins in Week 03
• First we need the other two surfaces: the editor and the terminal

AI in your editor and terminal

From browser to editor

Why integration matters

• Stay in your flow state: No context switching!
• Keep your hands on the keyboard: Faster than copy-paste workflows
• Context awareness: AI can see your entire project
• Real-time assistance: Get help as you type
• Workflow integration: Suggestions appear beside the code and tools being used

Open with the value proposition - students should understand why we’re moving from the browser-based tools from last session to integrated development tools.

Emphasize “flow state” - the psychological concept of being fully immersed in coding. Context switching breaks flow and reduces productivity.

Make sure students have VS Code open and ready for the GitHub Copilot demonstration.

What’s GitHub Copilot?

• Purpose-built for coding and integrates directly into VS Code!
• Generates code and explanations from the prompt and available editor context
• Provides two main modes of assistance:
  • Inline suggestions: “Ghost text” appears as you type
  • Copilot Chat: Conversational interface within your editor
• Context-aware: Can use current files and repository context according to the selected mode and permissions

This is the primary specialized code assistant for the course. Make sure students understand that Copilot is fundamentally different from the conversational AI models - it’s purpose-built for code generation and editing.

Key point: Context awareness and integration. Copilot can see variable names, function signatures, imports, and other files in your project. This makes its suggestions much more relevant than general-purpose AI models working with isolated code snippets.

Inline suggestions

How it works:

• Write a descriptive comment about what you want to accomplish
• Start coding…
• Copilot appears as gray “ghost text”
• Press Tab to accept, Esc to reject
• Use Alt + ] (Windows) or Option + ] (Mac) to cycle through alternatives

Inline suggestion practices

Best practices:

• Clear comments are key:

  # Calculate the factorial of a positive integer

• Descriptive function names:

  calculate_factorial not calc_fact

• Type hints help:

  def factorial(n: int) -> int:

This is the “classic” Copilot experience that most people think of. Prepare a live demo:

1. Open a new Python file
2. Write a comment: “# A function that calculates the factorial of a number”
3. Start typing: “def factorial(n: int) -> int:”
4. Let Copilot complete the function
5. Show how to cycle through alternatives

Clear names and nearby context can improve a suggestion, but every completion still needs review and testing.

Copilot Chat modes

Your conversational partner

Common interaction modes (labels can change):

• Planning mode: Architectural decisions and project structure
• Ask mode: Questions, explanations, and debugging help
• Agent mode: Autonomous task completion and complex operations

When to use each Copilot Chat mode

Your conversational partner

When to use each mode:

• Planning: “How should I structure a student gradebook application?”
• Ask: “Explain this regex pattern” or “Why am I getting this error?”
• Agent: “Refactor this class to use data classes” or “Add error handling to all functions”

Use the current Copilot documentation and interface during class because labels and capabilities can change. Distinguish the interaction patterns:

Planning mode: High-level architectural decisions. Use when you’re not sure how to approach a problem.

Ask mode: Specific questions about existing code. Use when you need explanations or help debugging.

Agent mode: When you want the AI to perform specific, well-defined tasks autonomously. Use when you know what needs to be done but want AI to do the implementation.

Prepare examples for each mode to show during the demo.

Live demo

Building a Python utility with AI assistance:

1. Start with a comment: # A function that calculates compound interest
2. Let Copilot generate the function: Accept or refine the suggestion
3. Use Chat to enhance:
   • /explain the generated code
   • “Add a NumPy-style docstring and type hints”
   • Ask for candidate pytest cases derived from the function contract
4. Refactor and debug: Name the behavior to preserve or provide a failing test

This is the centerpiece demonstration. Have a live coding session where you build a small utility from scratch using only AI assistance. Suggested function: compound interest calculator.

Key moments to highlight: 1. How inline suggestions save typing 2. How chat can explain unfamiliar code 3. How proposed tests can still encode an incorrect assumption 4. How to iteratively improve code with AI feedback

If something goes wrong (AI gives bad suggestions), use it as a teaching moment about verification and human oversight.

Command-line AI assistants

Why use terminal-based AI?

• Stay in your workflow: No need to switch between terminal and browser
• Quick queries: Fast answers without leaving the command line
• Repository context: Can inspect relevant files when permission is granted
• Repeatable checks: Can help run the same local validation commands
• Permission boundaries: Review requested file access, commands, and data handling

Frame the terminal as another working surface, not a skill ranking. It is useful when the task already lives in a repository and the assistant needs local context or needs to run checks.

Antigravity CLI

Google’s coding agent in your terminal

• Launch with agy from inside the repository you want it to inspect.
• Ask questions, request a plan, inspect files, and propose edits from one session.
• Review requested permissions and commands before approval.
• Use the official setup guide because installation and authentication flows can change.

cd ~/is4010/is4010-labs
agy

Use the current official setup guide during class. The course-facing Google terminal tool is Antigravity CLI, launched with agy; installation and account flows may change.

GitHub Copilot CLI

GitHub’s coding agent in your terminal

• Install the standalone tool from the current official GitHub documentation.
• Launch with copilot from inside the repository you want it to inspect.
• It can reason about repository context, propose edits, and help run checks.
• Review its plan, permissions, commands, and final diff.

cd ~/is4010/is4010-labs
copilot

The current Copilot CLI is a standalone agent, not the older gh copilot suggest and gh copilot explain extension. Open the official install page during class instead of copying an installer command into the deck.

The comparison protocol

1. Start both agents in the same repository.
2. Give both the exact same small, testable prompt.
3. Compare correctness, assumptions, clarity, and proposed commands.
4. Select or combine an approach; do not accept changes merely because they look plausible.
5. Run uv run --directory week02 python -m pytest tests/ -v.
6. Inspect git diff before committing.

Use count_vowels for the live comparison so class mirrors Lab 02. CI can validate the code and journal structure, but it cannot inspect local tool installations.

Choosing your AI toolkit

Required working surfaces for this course:

• A browser chat of your choice
• GitHub Copilot in VS Code
• GitHub Copilot CLI
• Antigravity CLI

After Lab 02:

• Keep both CLIs installed so you can compare when useful.
• Use whichever browser, editor, and CLI combination best fits the task.
• Tool preference never replaces tests, inspection, or your responsibility for the result.

Give clear guidance on what students need vs. what’s nice to have.

Students install and try both CLI agents. The point is comparison and informed choice, not declaring one permanent winner.

One file, every tool: AGENTS.md

You just set up three agents. They can all read the same file.

• AGENTS.md is an open format: a README written for coding agents instead of for people
• Plain Markdown, no schema, no required headings; the agent simply reads the text you wrote
• It lives in the repository root, so any agent you launch there starts with the same briefing
• Over 20 tools read it, including GitHub Copilot, VS Code, Antigravity CLI, and Codex
• More than 60,000 open-source projects publish one

You already have one. Your fork of is4010-labs contains an AGENTS.md telling any agent that tests, workflows, and lab instructions are read-only.

Open https://agents.md/ and the labs repository’s own AGENTS.md side by side. The second one is the better demo because students are governed by it right now: it is the reason a well-behaved agent refuses to “just make the test pass.”

The motivating problem is the one they hit in Lab 02, retyping the same setup facts into every new session. AGENTS.md is where that context goes once, under version control, instead of into each conversation.

When a tool wants its own filename

Some agents also look for a name of their own:

• AGENTS.md, the common format, read by most tools including both CLIs you just installed
• .github/copilot-instructions.md, GitHub Copilot’s own custom-instructions file in VS Code
• CLAUDE.md, read by Claude Code

The practical rule: write AGENTS.md, then point the others at it.

• Copilot in VS Code reads AGENTS.md too, so the extra file is often unnecessary
• When a tool insists, make its file one line that references AGENTS.md rather than a second copy
• This course’s own website repository does exactly that: CLAUDE.md contains @AGENTS.md and nothing else
• Two copies of your project’s rules drift apart; one copy cannot

Do not turn this into a compatibility matrix; support changes constantly and the deck would go stale. The durable lesson is the single-source-of-truth habit, which is the same reason we do not paste the same constant into three modules.

Students write their own AGENTS.md in Week 08, and the final project requires one.

AI workflow: implementation

Daily development:

1. Start with comments: Describe your intent clearly
2. Use Copilot inline: Accept, modify, or reject suggestions
3. Chat for complex problems: Switch to conversational help when stuck
4. Command-line for quick help: Terminal-based queries for efficiency

AI workflow: review and submission

Code review and submission:

1. Repository task: Give a scoped task to a CLI agent started inside the repository
2. AI-assisted debugging: Use chat to identify and fix issues
3. Documentation: Generate NumPy-style docstrings and comments with AI help
4. Testing: Propose test cases, then inspect and run them

This gives students a complete workflow they can start using immediately.

Emphasize the progression: start with simple inline suggestions, graduate to conversational help for complex problems, and use specialized tools for specific tasks like code review.

The key insight: different tools for different phases of development. You wouldn’t use the same tool for initial brainstorming as you would for final code review.

Remember: you are the pilot

• AI provides suggestions → You make decisions
• AI explains possibilities → You choose the best approach
• AI generates code → You understand and verify it
• AI finds patterns → You apply domain knowledge
• Always maintain responsibility for the final product

Submission rule: Do not submit code you cannot explain and verify.

End with the core philosophy. Students should leave feeling empowered, not dependent.

The goal is to make students better programmers faster, not to replace their thinking. AI should accelerate learning and remove tedious barriers, but students must remain intellectually engaged.

Ask: “What questions do you have about integrating AI into your development workflow?”

Time for Lab 02

• Install and authenticate both CLI tools using their official documentation
• Give both agents the exact same count_vowels task, then select, test, and revise an implementation
• Complete week02/lab02.py and week02/lab02_prompts.md
• Run the provided tests, inspect git diff, push your work, and confirm the Lab 02 README badge is green
• The automated check validates both the Python behavior and the completed journal
• Navigate to week02/lab02.md for step-by-step instructions