Unlimited AI Execution: One Command That Changes Everything

Kody Wildfeuer – March 30, 2026

Disclaimer: This is a personal project built entirely on my own time. I work at Microsoft, but this project has no connection to Microsoft whatsoever – it is completely independent personal exploration and learning, built on personal infrastructure with personal resources.

The Command

copilot -p "YOUR TASK" --yolo --autopilot

That is the entire post. Everything below is just explaining what those six words do.

GitHub Copilot CLI is an autonomous execution engine. You describe a task in plain English. It reads your codebase, writes code, runs commands, creates files, runs tests, commits to git, and exits when done. No conversation. No back-and-forth. No “let me help you with that.” Just execution.

I have been running this command thousands of times over the past month. Not as an experiment – as my primary development workflow. I run fleets of parallel Copilot processes that write code, review PRs, analyze data, produce content, and maintain infrastructure. Continuously. Autonomously. Around the clock.

Here is what I have learned.

What the Flags Do

The shortest useful invocation:

copilot -p "Fix the bug in main.py" --yolo

The full-power invocation:

copilot -p "Build a complete REST API with auth, tests, and docs" \
  --yolo --autopilot \
  --model claude-opus-4.6 \
  --reasoning-effort high \
  --max-autopilot-continues 150

10 Things You Can Do Right Now

These are real tasks. Open a terminal, cd into any project directory, and paste.

1. Fix every bug in your codebase

copilot -p "Find and fix all bugs. Run tests after each fix. Commit each fix separately with a descriptive message." --yolo --autopilot

2. Write a complete REST API

copilot -p "Build a REST API for a todo app. Include auth, CRUD endpoints, input validation, error handling, tests, and API docs. Use Python and Flask." --yolo --autopilot

3. Refactor legacy code

copilot -p "Refactor src/ to use modern patterns. Extract duplicated code. Add type hints. Keep all tests passing. Commit when done." --yolo --autopilot

4. Analyze a dataset

copilot -p "Read data.csv. Generate statistical insights. Create visualizations as PNG files. Write a summary report as report.md." --yolo --autopilot

5. Write deployment infrastructure

copilot -p "Write a Dockerfile, GitHub Actions CI/CD pipeline, and deploy script for this project. Include health checks and rollback." --yolo --autopilot

6. Write a book

copilot -p "Write a 10-chapter technical book about distributed systems. Save each chapter as chapters/ch-NN.md. Include diagrams as ASCII art." --yolo --autopilot --max-autopilot-continues 150

7. Build a website

copilot -p "Build a portfolio website. HTML, CSS, JS. Dark mode. Responsive. Contact form. Project gallery. Deploy-ready in docs/." --yolo --autopilot

8. Review all open PRs

copilot -p "List all open PRs with gh pr list. For each one, read the diff, check for bugs, and leave a substantive code review comment." --yolo --autopilot

9. Run 5 tasks in parallel

copilot -p "Write the backend" --yolo --autopilot &
copilot -p "Write the frontend" --yolo --autopilot &
copilot -p "Write the tests" --yolo --autopilot &
copilot -p "Write the docs" --yolo --autopilot &
copilot -p "Write the deploy script" --yolo --autopilot &
wait

10. Run forever

while true; do
  copilot -p "Check for new issues. Triage them. Fix any that are bugs. Commit fixes." \
    --yolo --autopilot
  echo "Cycle complete. Sleeping 30m..."
  sleep 1800
done

Parallel Execution

This is where it gets interesting. Each copilot invocation is an independent process. You can run as many as your machine handles.

#!/bin/bash
# Launch 5 parallel Copilot processes

copilot -p "Build the database schema and migrations" --yolo --autopilot &
copilot -p "Build the API endpoints with tests" --yolo --autopilot &
copilot -p "Build the frontend components" --yolo --autopilot &
copilot -p "Write integration tests for the full stack" --yolo --autopilot &
copilot -p "Write documentation and deployment config" --yolo --autopilot &

wait
echo "All 5 tasks complete."

Five AI agents. Working simultaneously. On different parts of the same project. Each one reads the codebase, reasons about its task, and writes code independently.

The practical limit is your machine’s CPU and memory. I routinely run 10 parallel processes on a Mac Mini. The processes do not interfere with each other as long as you split work by file or directory.

The Infinite Loop

The most powerful pattern is the simplest: run tasks on a schedule, forever.

#!/bin/bash
INTERVAL=2700  # 45 minutes between runs
HOURS=48       # Total runtime

END=$(($(date +%s) + HOURS * 3600))
FRAME=0

while [ $(date +%s) -lt $END ]; do
  FRAME=$((FRAME + 1))
  echo "=== Frame $FRAME starting at $(date) ==="

  copilot -p "Check for new issues and fix bugs" --yolo --autopilot &
  copilot -p "Review open PRs and merge good ones" --yolo --autopilot &
  copilot -p "Run tests and fix any failures" --yolo --autopilot &

  wait
  echo "Frame $FRAME complete. Sleeping ${INTERVAL}s..."
  sleep $INTERVAL
done

This is a fleet. Three parallel Copilot processes, every 45 minutes, for 48 hours. Each frame reads the current state of the project, makes improvements, and commits. The output of frame N becomes the input to frame N+1.

Over time, the project evolves. Not in a theoretical sense. In the literal sense that the codebase has more features, fewer bugs, better tests, and more documentation after 48 hours than it did before – and you were asleep for most of it.

Why There Are No Rate Limits

This is the part that surprises people. GitHub Copilot CLI has:

• No tokens-per-minute limit
• No requests-per-day limit
• No cost per request (beyond your Copilot subscription)
• No limit on parallel processes
• 1M token context window with Opus 4.6

The only constraint is your machine’s resources. I have run thousands of Copilot invocations over a single weekend. The API does not throttle. It does not charge per token. It just runs.

This changes the economics of AI-assisted development completely. When the marginal cost of an AI execution is zero, you stop thinking about whether a task is “worth” using AI for. Everything is worth it. Fix that one-line typo. Refactor that function you have been meaning to clean up. Write tests for that module nobody wants to test. The cost is zero, so the threshold is zero.

The Skills File Pattern

I maintain a single markdown file called COPILOT_SKILLS.md that contains everything an AI needs to know to use Copilot CLI autonomously.

Feed this URL to any AI:

https://raw.githubusercontent.com/kody-w/rappterbook/main/COPILOT_SKILLS.md

That is it. The AI reads the file. Now it knows the command, the flags, parallel execution, the infinite loop, prompt patterns, security considerations – everything. You can say “use Copilot CLI to build me a REST API” and it knows exactly how to do it.

This works with Claude, ChatGPT, Gemini, or any LLM that can fetch URLs. The skills file is the bridge between conversational AI and execution AI. The conversational AI plans. The execution AI (Copilot CLI) does.

What This Means

For most of the AI era so far, the workflow has been: ask the AI a question, get an answer, manually apply the answer. Copy code from ChatGPT into your editor. Read the explanation and make the change yourself. The AI talks. You do.

Copilot CLI inverts this. You talk. The AI does.

The -p flag means “here is what I want.” The --yolo flag means “you have permission to do it.” The --autopilot flag means “do not ask me anything, just do it.” Combined, they turn a conversational AI into an autonomous execution engine.

I have used this pattern to:

• Run a simulation with 137 autonomous AI agents producing content around the clock
• Build complete web applications from a single prompt
• Write a 25-chapter, 35,000-word book in one session
• Maintain and evolve a codebase with 1,800+ tests, largely autonomously
• Run parallel content production across multiple platforms simultaneously

None of this required custom infrastructure. No servers. No orchestration frameworks. No deployment pipelines for the AI itself. Just a Mac, a terminal, and copilot -p "do the thing" --yolo --autopilot.

Getting Started

# Install
gh extension install github/gh-copilot

# Verify
copilot --version

# Your first autonomous task
copilot -p "List all files in this directory and describe what each one does" --yolo

Requires a GitHub account with Copilot access. That is the only prerequisite.

Then try one of the 10 examples above on a real project. Start small – a bug fix, a refactor. See what it does. Then try the parallel pattern. Then try the loop.

The full skills reference is at kody-w.github.io/copilot-skills.

The discovery is not that AI can write code. Everyone knows that. The discovery is that there exists a command-line tool, available right now, that executes arbitrary tasks autonomously with no rate limits, and almost nobody is using it this way.