Getting better results from Copilot Coding Agent 🆙

[mannyb325]

The newest member on your team can tackle tasks from your backlog with just a click of a button. This new teammate can work while you are in a meeting, grabbing coffee, or even while you catch up on your emails. It can help you innovate faster, clear technical debt, and focus on the more complex, challenging problems that require human creativity and strategic thinking. This teammate is Copilot Coding Agent, and it’s here to help you be a more productive developer.

How Copilot Coding Agent Works

Copilot Coding Agent runs independently in the background to complete assigned tasks. It works as an autonomous developer within the GitHub ecosystem. Copilot Coding Agent works by taking issues from your backlog. This means that the agent can evaluate tasks from the issue description. It then makes changes in an ephemeral dev environment using GitHub Actions and eventually opens a PR for you to review. This means that the agent gives a higher quality output when you use well-scoped issues with clear acceptance criteria.

Well-structured issues, along with custom instructions, act as prompts for the coding agent to evaluate and determine how it should tackle your issues. Issues should start with a clear and descriptive title that summarizes the issue at a high level. Next, the description should give all the necessary context and explain the purpose of the issue.

The Power of Sub-Issues

Complex tasks can be hard for the coding agent to understand. By breaking down larger, complex issues into a series of smaller, more focused sub-issues, you're not only organizing your work; you're providing the coding agent with a roadmap for success.

Some benefits of creating sub-issues are:

• Directing the Agent's Focus: Narrows the coding agent's focus from an ambiguous, large, complex task down to direct, actionable steps.
• Logical Sequencing: Building Step-by-Step: Breaks down coding tasks in a logical order.
• Targeted Feedback & Iteration: Streamlining the Review Process: Makes Pull Requests smaller and easier to follow and understand.

Leveraging Copilot and Issue Templates

If you need help structuring your issues and sub-issues, you can use Copilot to help you get better results from the coding agent. Copilot Chat allows you to describe issues or even create sub-issues in natural language and helps with structure and formatting. To create better issues at scale, you can also use issue templates to help standardize and streamline how your team opens issues, prompting consistency and saving time.

Get started today

Agentic workflows like Copilot Coding Agent help you be more productive and maximize your workday. You can take advantage of the coding agent, issue templates, and issues on Copilot Chat today!

[OyanibTech-iii]

wow

[alex46x]

This is a really well-written and insightful explanation of how Copilot Coding Agent works within the GitHub ecosystem. I especially appreciate how clearly it highlights the importance of structured issues and proper context. It’s easy to overlook these aspects, but they actually play a huge role in how effectively an automated coding agent can understand and execute tasks.

The explanation about the agent creating an ephemeral development environment using GitHub Actions and then opening a pull request is particularly interesting. It gives a clear picture of how the entire workflow is automated while still keeping the developer in control during the review process. That balance between automation and human oversight is very important.

The section on sub-issues stands out the most to me. Breaking down complex tasks into smaller, more focused parts not only improves clarity but also makes the development process much more manageable. It helps both the coding agent and human collaborators stay aligned, and it naturally leads to cleaner, more organized pull requests. This approach also makes debugging and iteration much easier.

I also like how the importance of clear titles and descriptive issue content is emphasized. Providing proper context, goals, and expectations ensures that the agent produces higher-quality results. In a way, it feels similar to writing good documentation or giving clear instructions to a teammate.

Overall, this provides a very practical and actionable guide on how to effectively use Copilot Coding Agent in real-world projects. It’s not just theoretical—it actually gives a clear workflow that developers can start applying immediately. I’m definitely interested in trying this structured approach in my own projects and seeing how it improves productivity and code quality.

Thanks for sharing such a detailed and thoughtful explanation!

[hafizbilalakbar]

To maximize GitHub Copilot Workspace accuracy, strictly follow the "Three Ps of Prompting": Provide context (open relevant project tabs), be Precise (give explicit functional goals), and pass Patterns (provide sample inputs/outputs). Additionally, always break large tasks down into small, iterative, and descriptive commits.

[omprxkash]

his is an excellent and clear explanation of how Copilot Coding Agent functions as a true teammate rather than just a coding tool. You've perfectly captured the transformative potential of having an autonomous developer working alongside you.

What Makes This Approach So Powerful
The way you describe it—as a "newest member on your team"—really resonates. This isn't about replacing developers but about augmenting human capability in the most practical way possible. The agent handles the predictable, well-defined work while humans focus on the creative, complex problems that truly require our unique strengths.

The Backlog Transformation
The most impactful point you make is about transforming backlogs from static to-do lists into active work queues. Many teams have backlogs that grow endlessly because "we'll get to it when we have time." Now, that backlog becomes a pool of work that can actually move forward autonomously.

The Art of Issue Crafting
Your emphasis on well-structured issues is crucial. This reminds me of the shift we saw with agile methodologies: the quality of input determines the quality of output. Teams will need to develop new skills in "issue craftsmanship"—learning to write clear, actionable tickets becomes as important as writing good code.

Real-World Impact Scenarios
I can immediately see how this changes daily work:

Sprint planning becomes more strategic when routine tasks can be delegated

Technical debt reduction becomes continuous rather than periodic

Feature experimentation becomes low-risk when prototypes can be generated quickly

Documentation updates can happen automatically with code changes

The Human-AI Partnership Evolution
What you're describing is the next evolution of developer tools. We've moved from:

Compilers (telling computers what to do)

IDEs (helping us write code faster)

Copilot (suggesting code as we type)

Coding Agent (executing complete tasks independently)

This progression shows we're heading toward truly collaborative AI partnerships where each party focuses on what they do best.

Getting Started Mindset
For teams adopting this, the key shift will be learning to delegate to AI effectively. It's similar to mentoring a junior developer—you need to provide clear context, break down complex problems, and review work thoughtfully. The payoff is having a teammate that never sleeps and consistently applies your team's standards.

Your explanation makes this technology feel accessible and immediately useful. It's not some distant future concept—it's a practical tool available today that can genuinely help developers be more productive and focused on meaningful work.

What's been your experience with the learning curve for teams adopting this approach? Have you found certain types of tasks particularly well-suited for the Coding Agent?

[hafizbilalakbar]

To maximize GitHub Copilot Workspace accuracy, strictly follow the "Three Ps of Prompting": Provide context (open relevant project tabs), be Precise (give explicit functional goals), and pass Patterns (provide sample inputs/outputs). Additionally, always break large tasks down into small, iterative, and descriptive commits.

[rudra-swnt-12]

JSON prompting can really help get better results from Copilot since it makes your instructions clearer and more structured. But it doesn’t work well for every situation. For example, if you’re giving Copilot a specific, well-defined task, JSON prompting can make a big difference in keeping it focused and accurate.

[nhockcuncon77]

Awesome write-up, thanks for sharing! 🙌 A few thoughts + questions from trying Copilot Coding Agent in practice:

What’s working well

Breaking epics into sequenced sub-issues with explicit acceptance criteria and definition of done massively improves PR quality.

Adding context blocks (stack, repo map, service owners, domain glossary) reduces “hallucinated” changes.

Using issue templates with required fields keeps prompts consistent.

What I’d add to the playbook

Issue template snippet (copy/paste):

Context: …

Goal / Outcome: …

Scope: In / Out

Constraints: APIs, schemas, perf budgets

Acceptance Criteria: Given/When/Then bullets

Tests required: unit/e2e/contract

Risk & rollback: plan + owner

Guardrails: repo allowlist, file/path denylist, max diff size, CI policy checks (lint, tests, SAST, license).

Telemetry: track cycle time, review rework %, test coverage deltas, escaped defects—so we can prove ROI.

[Uncle8475]

Okay, so imagine you have a robot intern that just lives in your GitHub. Sounds kinda crazy, but it's literally what's up.

This isn't just a fancy autocomplete—this thing is a whole agent. You know that backlog of tasks you keep ignoring? The one with all the "ugh, I'll do it later" stuff? You can just yeet those tasks at this agent. Then, while you're in a boring meeting, grabbing an iced coffee, or just mentally doomscrolling, it's silently in the background, grinding through your tickets.

It's a total game-changer for clearing out tech debt and doing all the mundane coding, so you can actually focus on the big, brain-burning problems that need a real human. It's like having a sidekick that handles all the boring work, making you look like a productivity god.

My Two Cents (The Opinion Para)

Listen, as someone who's constantly battling a million tabs and a to-do list that's longer than a TikTok scroll, this feels like the future. I'm not gonna lie, the idea of an AI just autonomously cracking out PRs is kinda terrifying at first—like, is it gonna break everything? But the genius is that it needs you to be a good manager. You can't just give it a vague "make it better" command. You have to write clear tickets with good acceptance criteria, which is a skill we all need anyway. It basically forces you to be more organized, and in return, you get hours of your life back. It's a W in my book.

How It Actually Works (No Cap)

It's a simple three-step slay:

1. You Assign the Vibe: You write a clear issue in your repo (or get Copilot Chat to help you write it). The agent scoops it up.
2. It Does the Thing: It goes into a sandboxed dev environment and goes to work, coding all by itself.
3. You Get the Credit: It opens a PR for you to review. You just check its work and merge. Easy.

The Secret Sauce: Sub-Issues, Fr.

Big, complex tasks are a lot for anyone—AI or not. The key is to break that giant, "I'm not doing that" issue into a bunch of baby issues.

Why? It's a total cheat code:
Focuses the Bot:** You're giving it a step-by-step roadmap instead of a giant, confusing mess.
Makes PRs Less Scary:** The Pull Requests are smaller, easier to read, and way less likely to have wild, random changes.
t Just Makes Sense:** It builds things in a logical order, like following a recipe.

Your New Workflow

Stop struggling. Use Copilot Chat to help you word your issues perfectly. And set up issue templates so your whole team is giving the agent the same high-quality instructions. It's all about working smarter, not harder.

[sanatan0511]

I think persona is the best to gettting the best result out of many of them .for example suppose you search for best coffee .
e,g- Hey sir suppose you are a citizen of xyz like xyz flavour and my time of drinking and likes xxx season .please prefer me best coffee

• soln - bingo! xyx is your coffee get desired and best resuts

[Sujith-Kulal]

Copilot Coding Agent improves developer productivity by autonomously completing well-defined backlog issues in an isolated environment and opening PRs for review. To get the best results, issues should be clearly scoped with proper acceptance criteria. Breaking down large tasks into sub-issues helps the agent focus, produce cleaner changes, and enables easier review. Using Copilot Chat to structure issues and issue templates also ensures consistency and scalability across projects. Overall, this approach helps teams accelerate innovation while reducing time spent on repetitive tasks.

[dimpal-yadav]

The newest member on your team can tackle tasks from your backlog with just a click of a button. This new teammate can work while you are in a meeting, grabbing coffee, or even while you catch up on your emails. It can help you innovate faster, clear technical debt, and focus on the more complex, challenging problems that require human creativity and strategic thinking. This teammate is Copilot Coding Agent, and it’s here to help you be a more productive developer.

How Copilot Coding Agent Works

Copilot Coding Agent runs independently in the background to complete assigned tasks. It works as an autonomous developer within the GitHub ecosystem. Copilot Coding Agent works by taking issues from your backlog. This means that the agent can evaluate tasks from the issue description. It then makes changes in an ephemeral dev environment using GitHub Actions and eventually opens a PR for you to review. This means that the agent gives a higher quality output when you use well-scoped issues with clear acceptance criteria.

Well-structured issues, along with custom instructions, act as prompts for the coding agent to evaluate and determine how it should tackle your issues. Issues should start with a clear and descriptive title that summarizes the issue at a high level. Next, the description should give all the necessary context and explain the purpose of the issue.

The Power of Sub-Issues

Complex tasks can be hard for the coding agent to understand. By breaking down larger, complex issues into a series of smaller, more focused sub-issues, you're not only organizing your work; you're providing the coding agent with a roadmap for success.

Some benefits of creating sub-issues are:

• Directing the Agent's Focus: Narrows the coding agent's focus from an ambiguous, large, complex task down to direct, actionable steps.
• Logical Sequencing: Building Step-by-Step: Breaks down coding tasks in a logical order.
• Targeted Feedback & Iteration: Streamlining the Review Process: Makes Pull Requests smaller and easier to follow and understand.

Leveraging Copilot and Issue Templates

If you need help structuring your issues and sub-issues, you can use Copilot to help you get better results from the coding agent. Copilot Chat allows you to describe issues or even create sub-issues in natural language and helps with structure and formatting. To create better issues at scale, you can also use issue templates to help standardize and streamline how your team opens issues, prompting consistency and saving time.

Get started today

Agentic workflows like Copilot Coding Agent help you be more productive and maximize your workday. You can take advantage of the coding agent, issue templates, and issues on Copilot Chat today!

The newest member on your development team, Copilot Coding Agent, can tackle tasks from your backlog at the click of a button. This autonomous agent works independently in the background—whether you’re in a meeting, grabbing coffee, or catching up on emails—allowing you to focus on complex problems that require human creativity and strategic thinking. By leveraging Copilot Coding Agent, you can innovate faster, clear technical debt, and increase overall productivity.

How Copilot Coding Agent Works
Copilot Coding Agent functions as an autonomous developer within the GitHub ecosystem. It evaluates issues from your backlog, interprets the description and acceptance criteria, makes changes in an ephemeral dev environment using GitHub Actions, and opens a pull request (PR) for your review. The agent produces higher-quality results when tasks are well-scoped and clearly defined, making structured issues essential.
The Power of Sub-Issues
For complex tasks, breaking them down into smaller, actionable sub-issues ensures the coding agent can follow a clear roadmap:
Directing the Agent’s Focus: Narrows the agent’s attention to actionable steps rather than ambiguous, large tasks.
Logical Sequencing: Allows tasks to be completed step by step in a structured manner.
Targeted Feedback & Iteration: Smaller PRs make the review process easier and faster.
Leveraging Copilot and Issue Templates
Copilot Chat can assist in structuring issues and sub-issues using natural language. Issue templates help standardize and streamline issue creation, ensuring consistency and improving results from the coding agent.
Get Started Today
Agentic workflows like Copilot Coding Agent help you maximize productivity and make the most of your workday. By combining issue templates, Copilot Chat, and well-structured issues, your team can leverage autonomous development to move faster and focus on higher-value work.

[raghavvmenon7]

Use Copilot Coding Agent by turning well-scoped issues into machine-actionable work: write a clear title, precise acceptance criteria, and any examples or inputs the agent needs; break big work into ordered sub-issues so the agent can make small, reviewable PRs; attach labels (e.g., agent, needs-spec) and a short custom-instructions block in the issue to tell the agent how to behave (style, tests, or files to avoid). Automate the flow with an issue template that enforces the structure, and a lightweight GitHub Actions workflow that triggers an ephemeral job (or your agent runner) whenever an issue is labeled for the agent — the job should run in an isolated environment, perform the changes, run tests/lint, and open a PR for human review. Keep PRs tiny, include targeted tests, and use sub-issues to sequence complex work: the agent performs the mechanical steps while you focus on the hard design and final review.

Example: ISSUE_TEMPLATE/agent-task.md (use for every agent-targeted issue)

name: Agent Task
about: Use this template for tasks intended for the Copilot Coding Agent
title: "[AGENT] Short descriptive title"
labels: ["agent", "needs-spec"]
assignees: []

Summary

One-line summary of the problem and why we need it.

Acceptance Criteria (required)

• Clear, testable acceptance criterion Welcome to GitHub product feedback #1
• Clear, testable acceptance criterion Feature Request: Select a column when adding an issue to a project #2
• Example input / expected output (if applicable)

Scope & Constraints

• Files/directories the agent should modify: src/, tests/
• Files to avoid: infra/, secrets/
• Performance or backwards-compatibility constraints (if any)

Sub-issues / Steps (optional but recommended for complex tasks)

1. Create helper function X and tests
2. Integrate helper into module Y
3. Add docs and a changelog entry

Custom instructions for the agent (keeps prompts concise)

• Coding style: follow project's ESLint/Prettier rules
• Write unit tests (target >= 80% coverage for changed code)
• Keep changes small and open one PR per sub-issue
• If uncertain, open a draft PR and add needs-human label

Notes / Links

• Related issue: #123
• Design doc: docs/design.md

Example: lightweight GitHub Actions workflow to trigger your agent runner

This workflow watches for the agent label on issues and dispatches a job that runs your agent script in an ephemeral environment. Replace ./scripts/run-agent.sh with the runner that integrates with Copilot Coding Agent, an internal runner, or GitHub Actions that orchestrates the ephemeral dev environment and PR creation.

name: Run Copilot Agent on labeled issue

on:
issues:
types: [labeled]

permissions:
contents: write
issues: write
pull-requests: write

jobs:
run-agent:
if: ${{ github.event.label.name == 'agent' }}
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4

 - name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: '18'
- name: Install deps
run: npm ci
- name: Fetch issue metadata
id: issue
run: |
echo "ISSUE_NUMBER=${{ github.event.issue.number }}" >> $GITHUB_OUTPUT
- name: Run agent (ephemeral dev environment)
env:
ISSUE_NUMBER: ${{ steps.issue.outputs.ISSUE_NUMBER }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
# ./scripts/run-agent.sh should:
# 1) read issue content
# 2) open ephemeral environment (or use GitHub Actions workspace)
# 3) apply changes, run tests, lint
# 4) commit to a branch and open a PR referencing the issue
./scripts/run-agent.sh
- name: Add comment on issue (agent started)
uses: peter-evans/create-or-update-comment@v4
with:
token: ${{ secrets.GITHUB_TOKEN }}
issue-number: ${{ github.event.issue.number }}
body: |
Copilot Coding Agent started working on this issue. It will open a draft PR when ready for review

[louelena898]

Thank you for this summary/review on how the Copilot's coding agent works 😄

[subhrajitsahoo72-in]

GitHub Copilot Coding Agent is like a junior developer working for you automatically

You give it a task (issue)
It writes code
Runs it
Creates a PR
You just review

You create an issue in GitHub
Agent reads the issue (like instructions)
It spins up a temporary environment using GitHub Actions
Writes code + tests
Pushes changes
Opens a Pull Request

The agent is only as smart as your issue
Big tasks confuse the agent.
Main Issue: Build Authentication
Sub-issues:
Create user model
Add login API
Add JWT logic
Add validation

Result:
Cleaner PRs
Easier review
Better output

Real benefit
Saves time ⏱️
Handles boring work (boilerplate, refactoring)
Lets you focus on architecture + logic

Don’t expect:

Perfect production code every time
Deep business logic understanding
You still need to:
Review code
Guide it
Fix edge cases

Use it for:
CRUD APIs
Refactoring
Tests
Small features

Avoid for:
Complex architecture decisions
Critical security logic

(An intern who works fast but needs clear instructions)

[subhrajitsahoo72-in]

hope i describe clearly

[Ryan-Guo123]

I am validating a small open-source workflow around the review side of Copilot/Codex-style agent work, and this discussion is close to the exact pain I am trying to understand.

Disclosure: the project is mine / my repo: https://github.com/Ryan-Guo123/relay-codex

The narrow question is not “do we need another AI reviewer?” Tools like Copilot code review, CodeRabbit, Graphite, Qodo, and PR-Agent already cover that surface. I am testing whether maintainers still want a lightweight handoff artifact before/alongside review: what changed, what was verified, what still needs human review, and whether the PR should be reviewed, split, or sent back.

For anyone here who reviews AI-generated PRs, I would be grateful for a blunt 10-minute outcome on either the reviewer packet or the copy-paste external trial workflow:

• reviewer packet: https://github.com/Ryan-Guo123/relay-codex/blob/main/docs/round1-reviewer-request.md
• external repo trial: https://github.com/Ryan-Guo123/relay-codex/blob/main/docs/external-repo-trial.md

Useful answers are one of: reused, edited_heavily, ignored, or confusing.

I also need to know whether this is useful in_addition, before_review, instead, or not_needed compared with existing AI PR review tools. Negative feedback is very welcome; if this is redundant, I would rather learn that now than keep building in the wrong direction.

[hafizbilalakbar]

The newest member on your team can tackle tasks from your backlog with just a click of a button. This new teammate can work while you are in a meeting, grabbing coffee, or even while you catch up on your emails. It can help you innovate faster, clear technical debt, and focus on the more complex, challenging problems that require human creativity and strategic thinking. This teammate is Copilot Coding Agent, and it’s here to help you be a more productive developer.

How Copilot Coding Agent Works

Copilot Coding Agent runs independently in the background to complete assigned tasks. It works as an autonomous developer within the GitHub ecosystem. Copilot Coding Agent works by taking issues from your backlog. This means that the agent can evaluate tasks from the issue description. It then makes changes in an ephemeral dev environment using GitHub Actions and eventually opens a PR for you to review. This means that the agent gives a higher quality output when you use well-scoped issues with clear acceptance criteria.

Well-structured issues, along with custom instructions, act as prompts for the coding agent to evaluate and determine how it should tackle your issues. Issues should start with a clear and descriptive title that summarizes the issue at a high level. Next, the description should give all the necessary context and explain the purpose of the issue.

The Power of Sub-Issues

Complex tasks can be hard for the coding agent to understand. By breaking down larger, complex issues into a series of smaller, more focused sub-issues, you're not only organizing your work; you're providing the coding agent with a roadmap for success.

Some benefits of creating sub-issues are:

• Directing the Agent's Focus: Narrows the coding agent's focus from an ambiguous, large, complex task down to direct, actionable steps.
• Logical Sequencing: Building Step-by-Step: Breaks down coding tasks in a logical order.
• Targeted Feedback & Iteration: Streamlining the Review Process: Makes Pull Requests smaller and easier to follow and understand.

Leveraging Copilot and Issue Templates

If you need help structuring your issues and sub-issues, you can use Copilot to help you get better results from the coding agent. Copilot Chat allows you to describe issues or even create sub-issues in natural language and helps with structure and formatting. To create better issues at scale, you can also use issue templates to help standardize and streamline how your team opens issues, prompting consistency and saving time.

Get started today

Agentic workflows like Copilot Coding Agent help you be more productive and maximize your workday. You can take advantage of the coding agent, issue templates, and issues on Copilot Chat today!

To maximize GitHub Copilot Workspace accuracy, strictly follow the "Three Ps of Prompting": Provide context (open relevant project tabs), be Precise (give explicit functional goals), and pass Patterns (provide sample inputs/outputs). Additionally, always break large tasks down into small, iterative, and descriptive commits.

[Zero-day-Exploit-np]

Copilot Coding Agent is an AI assistant that helps developers' complete tasks automatically from GitHub issues.

It works in the background by taking tasks from a backlog, understanding the issue description, and then making code changes in a temporary environment. After completing the work, it creates a Pull Request for review.

How it works:

1. It reads a GitHub issue
2. Understands the task and requirements
3. Makes changes in a safe temporary environment (GitHub Actions)
4. Opens a Pull Request for review

Why it is useful:

1. Saves time by automating small coding tasks
2. Helps reduce technical debt
3. Allows developers to focus on complex problems
4. Works even while developers are offline or busy

Best practice:

1. Write clear and well-defined issues
2. Break large tasks into smaller sub-issues
3. Include acceptance criteria for better results

Benefits of sub-issues:

1. Makes tasks easier for the AI to understand
2. Breaks complex work into smaller steps
3. Makes code review easier and faster

Conclusion:
Copilot Coding Agent improves productivity by automating issue-based development and works best when tasks are clearly structured and broken into smaller steps.

[Suryanshtiwari2005]

Honestly, this is a pretty exciting shift in how we think about "who" is on a dev team. Copilot Coding Agent basically turns GitHub Issues into something you can hand off to an AI teammate instead of just tracking work for yourself. You write up a task, assign it to the agent, and it goes off and works on it in its own sandboxed environment while you're doing literally anything else in a meeting, grabbing coffee, clearing your inbox. Once it's done, it doesn't just dump code on you, it opens a proper PR so you review it the same way you'd review a teammate's work.

What I find most interesting is that the quality of what you get back is directly tied to how well you write the issue in the first place. Vague tickets get vague results. Clear titles, solid context, and actual acceptance criteria are what make the agent actually useful instead of just noise you have to clean up later.

The other big takeaway for me is the sub-issues angle. Instead of throwing one huge, complicated task at it, breaking things down into smaller logical steps gives the agent a much clearer path to follow and as a bonus, it keeps the resulting PRs small enough to actually review properly instead of drowning in a massive diff. It's a good reminder that even with AI doing the "typing," good project management habits don't go away if anything they matter more.

Feels like the real skill we need to build now isn't just writing code, it's writing really clear, well-scoped tickets that an agent (or a human) could pick up and run with.

[tsuryansh800-oss]

This tracks with what I've noticed using AI coding tools myself the gap between a vague prompt and a tight, well-scoped one is wild. Same as it's always been with delegating to junior devs or interns, except now the "person" never gets tired of you re-explaining the ask. The sub-issue point especially resonates: small, reviewable diffs aren't just easier for the agent to nail, they're easier for you to actually verify it didn't quietly break something three files away. Feels like the bottleneck in software is shifting from "can you write the code" to "can you decompose the problem clearly enough that someone (or something) else could execute it." Honestly that's a underrated skill even on human teams most PR review pain I've seen comes from tickets that were never scoped tightly to begin with.