GitHub Copilot + GPT Agents: An Experiment in Assisted Development

Project Overview

This is a short, personal prototype exploring what happens when GitHub Copilot is used alongside small, specialized GPT agents to assist a developer through the lifecycle of a feature: design, implementation, tests, docs, and CI.

I built this as a test project while exploring ways to reduce the friction of routine engineering tasks. The idea is simple: instead of relying on a single autocomplete model, use a set of focused agents (or prompts) that collaborate and hand off work to each other. The human remains in the loop to review and guide decisions.

Story

I started this project during an afternoon of tinkering. The first success was surprising: asking a "design agent" to sketch a small API and then having a "code agent" implement it produced usable TypeScript scaffolding in one pass. The next step—having a "test agent" produce unit tests—caught several edge cases I hadn't thought about. Finally, a "doc agent" produced a user-friendly README that was accurate enough to be helpful with only minor edits.

That immediate feedback loop made the experiment feel less like pair-programming and more like having a short-lived team of tiny experts that can be spun up on demand.

Features

• Design agent: transforms a short requirement into an API contract and a tiny architecture sketch.
• Code agent: implements the API scaffolding, wiring, and a minimal example.
• Test agent: writes unit tests for key behaviors and edge cases.
• Doc agent: generates usage examples and a readable README.
• Orchestration notes: a simple coordination pattern where outputs are stored as artifacts and passed between agents for review.

Architecture (conceptual)

1. Human writes a short requirement or prompt.
2. Design agent expands the prompt into an API spec (endpoints/functions, inputs/outputs).
3. Code agent receives the spec and generates code files.
4. Test agent generates tests that exercise both normal and edge cases.
5. Doc agent writes the README and usage examples.
6. Human reviews, edits, and commits.

This experiment intentionally keeps orchestration simple—artifacts are passed as text files and the human is the final arbiter.

How I used GitHub Copilot in this workflow

I used GitHub Copilot inside the editor for rapid in-line completions and then used GPT-based agents (via prompts or scripted calls) for higher-level tasks: generating full files, unit tests, or documentation. Copilot handled low-latency, local completion needs; the agents handled multi-step reasoning and file-level outputs.

Why this felt effective

• Division of labor: each agent focuses on a single responsibility which reduces prompt engineering complexity.
• Fast iteration: agents produce full files instead of line-by-line completions, which made larger changes feel faster.
• Safety net: tests written by the test agent helped catch obvious logic mistakes before I ran the code.

Learnings

• Prompt-shaping matters: the design agent succeeds when given clear constraints (API shape, error handling policy, target runtime).
• Human review remains essential: agents are good at scaffolding but will hallucinate specifics if the prompt is ambiguous.
• Small modular agents are easier to reason about and reuse across projects than a single monolithic prompt.
• Tooling around passing structured artifacts (JSON spec, OpenAPI fragment) between agents reduces ambiguity.

Example (mini workflow)

1. Write a short requirement: "Create a small REST endpoint that returns a leaderboard of players with score and rank."
2. Run the design agent → returns an OpenAPI-like spec and model types.
3. Run the code agent → creates a small Express/TypeScript route and an in-memory repository.
4. Run the test agent → creates unit tests asserting sorting and rank ties.
5. Accept, tweak, commit.

Future work

• Create a simple CLI to orchestrate the agents and persist artifacts to a workspace directory.
• Add a lightweight verification agent that runs tests automatically and reports failures as comments.
• Experiment with authentication-sensitive prompts that redact secrets and enforce safe defaults.
• Evaluate a cost/performance tradeoff between very small agents vs. a single large agent.

Notes for curious readers

This is a conceptual prototype and a thought experiment more than a production system. If you'd like to reproduce the idea locally, keep the components minimal:

• Use one prompt per agent and keep the prompt templates in a folder.
• Keep artifact formats simple (Markdown for design, JSON for specs, plain files for code/tests).
• Make the human review step explicit in your workflow; agents are assistants, not autopilots.

Learnings & takeaway

Combining GitHub Copilot for quick in-editor completions with a few focused GPT agents for higher-level file and test generation can drastically reduce friction when building small features. The right balance between automation and review preserves quality while speeding up iterations.

Acknowledgements

Thanks to the tiny, ephemeral colleagues (design, code, test, doc agents) that make prototyping feel faster and a bit more fun.

What I would open next

• src/ to add a minimal example implementation
• scripts/ to add small orchestration helpers
• README.md to document the experiment and how to run the CLI