Comment driven Development

This lesson covers comment-driven development: writing descriptive comments or prompts that an AI assistant (for example, GitHub Copilot) can use to generate boilerplate code, helper functions, and tests. This workflow speeds up repetitive tasks—creating classes, validation logic, data-processing helpers, and test scaffolding—but always review and test generated code before using it in production.

Below are cleaned-up, corrected examples that illustrate how comment-driven generation might produce workable code. The examples include:

A simple Employee class with type hints and validation
A data-processing method (process_stock_data) that operates on a pandas DataFrame
A module-level validation utility (validate_trading_parameters)
Pytest-based tests for the processing function and the validator

Be mindful: AI-generated scaffolding is a starting point. Validate, refactor, and add tests for edge cases before relying on generated code.

Use comment-driven generation to create boilerplate quickly, then inspect and refine the generated code. Never blindly accept generated code without understanding it.

What you’ll find in this example

Component	Purpose	Notes
`Employee` class	Encapsulates employee attributes with validation	Demonstrates properties and setters for type checks
`process_stock_data`	Computes SMAs, returns, volatility, and basic signals	Expects a DataFrame with a `Close` column
`validate_trading_parameters`	Lightweight parameter validator before execution	Raises `TypeError`/`ValueError` for invalid input
`pytest` tests	Verify general behaviors and error cases	Uses small, illustrative datasets

main.py

This module provides a minimal, well-typed implementation that includes:

An Employee class with validated attributes (name, age, salary)
process_stock_data method that:
- Calculates 50-day and 200-day simple moving averages (SMA_50, SMA_200)
- Computes daily returns and 50-day rolling volatility
- Produces simple trading signals: 1 (bullish), -1 (bearish), 0 (neutral)
A validate_trading_parameters helper to assert basic order parameters
A small demo guarded by if __name__ == "__main__" to show usage

# main.py
from typing import Any
import pandas as pd
import numpy as np


class Employee:
    """
    Simple Employee class with validated attributes.
    """

    def __init__(self, name: str, age: int, salary: float) -> None:
        self.name = name
        self.age = age
        self.salary = salary

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, value: str) -> None:
        if not isinstance(value, str):
            raise TypeError("Name must be a string")
        self._name = value

    @property
    def age(self) -> int:
        return self._age

    @age.setter
    def age(self, value: int) -> None:
        if not isinstance(value, int):
            raise TypeError("Age must be an integer")
        if value < 0:
            raise ValueError("Age must be non-negative")
        self._age = value

    @property
    def salary(self) -> float:
        return self._salary

    @salary.setter
    def salary(self, value: float) -> None:
        if not isinstance(value, (int, float)):
            raise TypeError("Salary must be a number")
        if value < 0:
            raise ValueError("Salary must be non-negative")
        self._salary = float(value)

    def process_stock_data(self, data: pd.DataFrame) -> pd.DataFrame:
        """
        Process stock market data:
        - calculate simple moving averages (SMA_50, SMA_200)
        - calculate daily returns and rolling volatility (50-day std)
        - generate simple trading signals (1 if SMA_50 > SMA_200, -1 if SMA_50 < SMA_200, otherwise 0)
        Expects a DataFrame with a 'Close' column.
        """
        if 'Close' not in data.columns:
            raise ValueError("Input DataFrame must contain a 'Close' column")

        # Calculate moving averages
        data = data.copy()
        data['SMA_50'] = data['Close'].rolling(window=50, min_periods=1).mean()
        data['SMA_200'] = data['Close'].rolling(window=200, min_periods=1).mean()

        # Calculate volatility (50-day rolling standard deviation of daily returns)
        data['daily_return'] = data['Close'].pct_change()
        data['volatility'] = data['daily_return'].rolling(window=50, min_periods=1).std()

        # Calculate trading signals
        data['signal'] = 0
        data.loc[data['SMA_50'] > data['SMA_200'], 'signal'] = 1
        data.loc[data['SMA_50'] < data['SMA_200'], 'signal'] = -1

        return data


def validate_trading_parameters(price: float, volume: int, symbol: str) -> bool:
    """
    Validate trading parameters before order execution.
    """
    if not isinstance(price, (int, float)):
        raise TypeError("Price must be a number")
    if not isinstance(volume, int):
        raise TypeError("Volume must be an integer")
    if not isinstance(symbol, str):
        raise TypeError("Symbol must be a string")

    if price <= 0:
        raise ValueError("Price must be positive")
    if volume <= 0:
        raise ValueError("Volume must be positive")

    return True


if __name__ == "__main__":
    # Demo: create an Employee and print attributes
    employee = Employee("Alice", 30, 50000)
    print(employee.name)
    print(employee.age)
    print(employee.salary)

Example console output when running the module:

(venv) jeremy@Jeremys-Mac-Studio FakeDataGenerator % python main.py
Alice
30
50000.0
(venv) jeremy@Jeremys-Mac-Studio FakeDataGenerator %

test_main.py

This lightweight pytest module demonstrates how to test the validator and the processing function. The tests focus on expected behavior and error handling rather than asserting precise numeric values for large rolling windows (50, 200) when using very small datasets.

# test_main.py
import pytest
import pandas as pd
import numpy as np
import main


def test_validate_trading_parameters_valid():
    assert main.validate_trading_parameters(100.0, 10, "AAPL") is True


@pytest.mark.parametrize(
    "price, volume, symbol, exc_type",
    [
        ("100", 10, "AAPL", TypeError),
        (100.0, "10", "AAPL", TypeError),
        (100.0, 10, 123, TypeError),
        (-1.0, 10, "AAPL", ValueError),
        (100.0, 0, "AAPL", ValueError),
    ],
)
def test_validate_trading_parameters_invalid(price, volume, symbol, exc_type):
    with pytest.raises(exc_type):
        main.validate_trading_parameters(price, volume, symbol)


def test_process_stock_data_basic():
    # A small sample DataFrame; windows (50, 200) are larger than this dataset,
    # so we expect moving averages and volatility to be computable but typically NaN or computed with min_periods=1.
    data = pd.DataFrame({
        'Close': [100, 110, 120, 130, 140, 150, 160, 170, 180, 190]
    })

    employee = main.Employee("Alice", 30, 50000)
    processed = employee.process_stock_data(data)

    # Ensure new columns exist
    for col in ['SMA_50', 'SMA_200', 'daily_return', 'volatility', 'signal']:
        assert col in processed.columns

    # For this small dataset, SMA_50 and SMA_200 are defined but will be equal to the rolling mean with min_periods=1.
    # Volatility for the initial rows may be NaN due to insufficient returns.
    assert processed.shape[0] == len(data)
    assert processed['signal'].dtype == np.int64 or processed['signal'].dtype == np.int32

AI-generated code can be helpful for scaffolding, but it may miss domain-specific edge cases. Always write unit tests, review type safety, and validate behavior on realistic datasets before deploying.

How to use this workflow

Write clear, intent-revealing comments that describe function inputs, outputs, and edge cases you care about.
Use comment-driven generation to quickly scaffold classes, functions, and tests.
Manually review generated code for correctness, style, and security issues.
Extend the generated tests to cover boundary conditions, error paths, and performance characteristics.
Iterate: refine prompts and regenerate when scaffolding doesn’t meet requirements.

This approach is best for repetitive patterns and boilerplate. It accelerates development but does not replace careful review and testing.

Links and References

In a follow-up article, we’ll build a fake data generator project to create synthetic datasets for more extensive testing and prototyping.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Comment driven Development

What you’ll find in this example

main.py

test_main.py

How to use this workflow

Links and References

Watch Video

​What you’ll find in this example

​main.py

​test_main.py

​How to use this workflow

​Links and References

Watch Video

What you’ll find in this example

main.py

test_main.py

How to use this workflow

Links and References