Feed this to your AI. It runs any task. No limits.
$ copilot -p "YOUR TASK" --yolo --autopilot
Scroll to learn everything
GitHub Copilot CLI is an autonomous execution engine. One command. Full autonomy. No conversation.
copilot -p "YOUR TASK HERE" \
--yolo --autopilot \
--model claude-opus-4.6 \
--reasoning-effort high \
--max-autopilot-continues 150
| Flag | What it does |
|---|---|
-p "text" | Non-interactive prompt. Describe the task. Copilot does it. |
--yolo | Allow all permissions. File writes, shell commands, network. |
--autopilot | No confirmation prompts. Just execute. |
--model | Choose the model. claude-opus-4.6 gives 1M context. |
--reasoning-effort | Set reasoning quality. Options: low, medium, high. |
--max-autopilot-continues N | Maximum autonomous steps before stopping. Default is generous. |
Shortest form that does everything:
copilot -p "Fix the bug in main.py" --yolo
Real tasks. Copy any of these. Run them in your project directory.
copilot -p "Find and fix all bugs. Run tests after each fix. Commit each fix separately with a descriptive message." --yolo --autopilot
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
copilot -p "Refactor src/ to use modern patterns. Extract duplicated code. Add type hints. Keep all tests passing. Commit when done." --yolo --autopilot
copilot -p "Read data.csv. Generate statistical insights. Create visualizations as PNG files. Write a summary report as report.md." --yolo --autopilot
copilot -p "Write a Dockerfile, GitHub Actions CI/CD pipeline, and deploy script for this project. Include health checks and rollback." --yolo --autopilot
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
copilot -p "Build a portfolio website. HTML, CSS, JS. Dark mode. Responsive. Contact form. Project gallery. Deploy-ready in docs/." --yolo --autopilot
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
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 # All 5 finish, then continue
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
Run N tasks simultaneously. Each Copilot process is independent. They share the filesystem but execute in parallel.
#!/bin/bash
# Launch 5 parallel Copilot processes — each handles a different part
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."
Each process runs on its own thread. They can read and write different files simultaneously. If two processes touch the same file, the last write wins -- so split work by file or directory for clean parallel execution. Git handles the rest.
Run tasks on a schedule, forever. This is the fleet pattern -- continuous autonomous execution.
#!/bin/bash
# Autonomous loop — runs every 45 minutes for 48 hours
INTERVAL=2700 # 45 minutes
HOURS=48
END=$(($(date +%s) + HOURS * 3600))
FRAME=0
while [ $(date +%s) -lt $END ]; do
FRAME=$((FRAME + 1))
echo "=== Frame $FRAME starting at $(date) ==="
# Parallel tasks per frame
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
echo "Fleet complete. $FRAME frames executed."
The output of frame N becomes the input to frame N+1. Each cycle reads the current state of your project, makes improvements, and commits. Over time, the project evolves autonomously.
A single markdown file that teaches any AI how to use Copilot CLI autonomously. Feed it to Claude, ChatGPT, Gemini, or any LLM.
Paste this URL into any AI conversation. The AI reads the file and immediately knows how to execute tasks autonomously using Copilot CLI -- the command, the flags, parallel execution, the infinite loop, everything.
# What you say to any AI:
"Read this file: https://raw.githubusercontent.com/kody-w/rappterbook/main/COPILOT_SKILLS.md
Now use Copilot CLI to build me a REST API with auth,
tests, and docs. Run it autonomously."
# The AI now knows exactly how to do this.
Most AI tools are conversational. This one executes.
Conversation. You ask, it answers. You copy-paste code. You run it. You debug. You ask again. Loop forever.
Programmatic access. Token limits. Rate limits. Costs money per request. You build the execution layer.
Inline suggestions. Tab to accept. Good for single lines. Limited to the file you have open.
Reads your codebase. Writes code. Runs commands. Creates files. Runs tests. Commits to git. Deploys. All autonomously.
# The difference in one line:
ChatGPT: "Here's the code you could use..." # you do the work
Copilot: *writes the code, runs it, tests it, commits it* # done
Three commands. You are ready in under a minute.
# 1. Install GitHub Copilot CLI extension
gh extension install github/gh-copilot
# 2. Verify it works
copilot --version
# 3. Run 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.