Demo Inline Suggestions

This lesson covers inline suggestions: how they appear as you type, how multiple alternatives and comment-driven suggestions work, and how the “Next Edit Suggestions” feature helps during edits and refactors. Inline suggestions (like those from GitHub Copilot) make educated completions for identifiers, decorators, and function bodies as you type. For example, typing current_te can autocomplete to current_test_id based on other usages in the file, speeding up repetitive tasks and reducing context switching. Below is a compact, corrected Flask example used throughout this lesson. It uses an in-memory list as a simple database and provides a POST route to create items.

from flask import Flask, request, jsonify
from models import Item  # Assumes Item is a dataclass or model that can be serialized

app = Flask(__name__)

# In-memory database
items_db = []
current_id = 1

# Create
@app.route('/items', methods=['POST'])
def create_item():
    global current_id
    data = request.get_json()

    if not data or 'name' not in data:
        return jsonify({'error': 'Name is required'}), 400

    new_item = Item(
        id=current_id,
        name=data['name'],
        description=data.get('description', '')
    )

    # If Item is not JSON serializable by default, convert to dict before appending/returning
    # items_db.append(new_item.__dict__)
    items_db.append(new_item)
    current_id += 1

    return jsonify({'message': 'Item created', 'item': new_item.__dict__}), 201

Inline completion behavior

Identifiers: As you type a variable or function name, suggestions can complete them based on nearby usage.
Routes & handlers: Typing a decorator such as @app.route or beginning a handler name can produce a full route + handler implementation suggestion.

A concise implementation for deleting all items, which inline completions commonly suggest, looks like this:

@app.route('/items', methods=['DELETE'])
def delete_all_items():
    # Clear the in-memory list in-place to avoid reassigning the global variable
    items_db.clear()
    return jsonify({'message': 'All items deleted successfully'}), 200

Prefer items_db.clear() to reassigning the global name (e.g., items_db = []). Clearing in-place preserves references and avoids rebinding the global variable, which is safer when other parts of the code hold references to the list.

Comment-driven suggestions Writing a clear comment describing a desired behavior can trigger inline suggestions that expand the comment into a complete implementation. For example, starting with:

# create a route to generate a number of random items
@app.route('/create_random', methods=['POST'])
def create_random_items():
    pass

An inline suggestion can replace pass with a full implementation. Here is a sample handler that creates N random items (requires the random module):

import random

@app.route('/create_random', methods=['POST'])
def create_random_items():
    data = request.get_json() or {}
    count = int(data.get('count', 1))

    global current_id
    created = []

    for _ in range(max(0, count)):
        item = Item(
            id=current_id,
            name=f"Item {current_id}",
            description=f"Random item {random.randint(1, 1000)}"
        )
        items_db.append(item)
        created.append(item.__dict__)
        current_id += 1

    return jsonify({'created': created}), 201

Placeholders and small utilities You can add small placeholder routes (for quickly sketching behavior) and let inline suggestions fill in details later. For example:

@app.route('/readcsv', methods=['GET'])
def read_csv():
    # Inline suggestions can fill in the implementation for reading/parsing a CSV
    return jsonify({'message': 'CSV read not implemented'}), 501

Multiple inline suggestions and selecting alternatives When a handler name or comment is ambiguous, the assistant might offer multiple alternative completions. You can browse and choose the most appropriate suggestion. Example: a robust suggestion for analyzing a posted list of numbers validates input and returns basic statistics:

@app.route('/analyzenumbers', methods=['POST'])
def analyze_numbers():
    data = request.get_json()

    if not data or 'numbers' not in data:
        return jsonify({'error': 'Numbers are required'}), 400

    numbers = data['numbers']

    if not isinstance(numbers, list) or not all(isinstance(n, (int, float)) for n in numbers):
        return jsonify({'error': 'Numbers must be a list of numeric values'}), 400

    count = len(numbers)
    total = sum(numbers)
    average = total / count if count else 0

    analysis = {
        'count': count,
        'sum': total,
        'average': average,
        'min': min(numbers) if count else None,
        'max': max(numbers) if count else None
    }

    return jsonify(analysis), 200

Inline editor chat Right-clicking a symbol (for example, analyze_numbers) in many editors lets you open an inline assistant/chat to ask for rewrites, extensions, or refactors in-context. This interactive experience produces alternative implementations you can accept or reject. Next Edit Suggestions (Settings) Next Edit Suggestions surface likely follow-up edits after you make a change (rename a variable, refactor a function, etc.). Enable this feature in your editor’s Copilot settings to receive guided suggestions for related edits. The UI for these settings typically looks like this:

A dark-themed code editor settings screen (likely VS Code) open to GitHub Copilot preferences. The left pane shows a file explorer with Python files, while the main pane lists Copilot options like inline auto-completions and language-specific enable/disable values.

Next Edit Suggestions are particularly helpful when a single change implies multiple consistent edits across the file — for example, renaming items_db in one place and then accepting the assistant’s proposal to update related usages nearby.

Next Edit Suggestions are useful during refactoring — they propose subsequent edits related to the change you’re making. This feature may be in preview or evolve over time.

Routes quick reference

Route	Method	Purpose	Example response
`/items`	`POST`	Create a new item	`{'message': 'Item created', 'item': {...}}`
`/items`	`DELETE`	Delete all items	`{'message': 'All items deleted successfully'}`
`/create_random`	`POST`	Create N random items	`{'created': [{...}, {...}]}`
`/readcsv`	`GET`	Placeholder for CSV read	`{'message': 'CSV read not implemented'}`
`/analyzenumbers`	`POST`	Analyze list of numbers	`{'count': 3, 'sum': 6, 'average': 2.0, 'min': 1, 'max': 3}`

Links and references

Flask documentation: https://flask.palletsprojects.com/
GitHub Copilot docs and settings: https://docs.github.com/en/copilot
Python documentation: https://docs.python.org/3/

Wrap-up This lesson demonstrated how inline features help in practice:

Inline completions that finish code you are actively typing.
Multiple suggestions and alternative completions you can pick between.
Comment-driven suggestions that expand comments into working code.
Next Edit Suggestions that propose follow-up edits while refactoring.

These inline tools can significantly speed up common coding tasks — but always review generated code for correctness, security, and maintainability.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Demo Inline Suggestions

Watch Video