Welcome to the first post in my series on getting the most out of GitHub Copilot in the terminal. We'll kick things off with one of the most important things to understand: the different modes Copilot CLI operates in, and when to reach for each one.

A quick intro to GitHub Copilot CLI

GitHub Copilot CLI is a terminal-native coding agent — not just a chat wrapper. It can plan complex tasks, edit files, run tests, and iterate autonomously, all without leaving your terminal. But to get the most out of it, you need to understand how to control how much autonomy you give it at any point in time. That's exactly what the different modes are for.

You cycle through the main modes using Shift+Tab. A mode indicator in the CLI's footer tells you which one you're currently in.

The three main modes

1. Standard Mode — The default

When you launch copilot, you start in standard (interactive) mode. This is the classic back-and-forth: you submit a prompt, Copilot responds or takes an action, and then waits for your next instruction. It will ask for your approval before executing any tool or shell command that requires permission.

This mode gives you the most control and is the right starting point for most tasks — especially exploratory ones where you want to stay hands-on and guide the work step by step.

Best for: open-ended exploration, iterative development, tasks where you want to review each step before moving on.

2. Plan Mode — Think before you build

Press Shift+Tab to cycle into plan mode. Instead of immediately starting to write code or execute commands, Copilot shifts into a collaborative planning phase. It asks you clarifying questions, confirms its understanding of scope and requirements, and builds a structured implementation plan before touching a single file.

Once you've reviewed and approved the plan — which appears in a dedicated panel in the UI — you can tell Copilot to start implementing. You can even hand off directly to autopilot mode from there with "Accept plan and build on autopilot."

Plan mode is particularly valuable for complex, multi-step tasks. Catching a misunderstanding at the planning stage is far cheaper than untangling a half-implemented feature.

Best for: new features, refactors, anything where getting the approach right upfront matters.

Pro tip: If you see that Copilot is going off rails, you can always interrupt and provide some input or feedback. Copilot will pick this up and change the plan accordingly.

3. Autopilot Mode — Hands-off execution

Keep pressing Shift+Tab to reach autopilot mode. In this mode, Copilot works autonomously through a task without pausing for your input at each step. It continues executing — editing files, running commands, calling tools — until it determines the task is complete, hits an error it can't resolve, or you press Ctrl+C to stop it.

Autopilot mode works best with explicit tool permissions. You can launch the CLI with --allow-all to grant full permissions upfront (or through the /allow-all slash command), or use --max-autopilot-continues to cap how many steps the agent can take before stopping — a good safety net for tasks you're less certain about.

Best for: well-defined tasks you trust Copilot to handle end-to-end — writing tests, fixing CI failures, applying a well-understood refactor across multiple files.

Pro tip: Autopilot is not ideal for open-ended or ambiguous tasks. If the goal isn't crystal clear, you risk getting a pile of changes that don't quite hit the mark. Use plan mode first to align on the approach, then hand off to autopilot.

Shell Mode — Bypassing the agent entirely

Shell mode is a bit different from the three above — it's not part of the Shift+Tab cycle. Instead, you access it by prefixing any prompt with !. This executes the command directly in your shell without making a call to the model at all.

! git status
! npm test
! ls -la src/

This is handy when you're mid-conversation with Copilot and want to quickly check something in your environment — run a test, inspect a file, check git status — without starting a new terminal or breaking your flow. Think of it as a built-in escape hatch to your shell.

Best for: quick environment checks, running commands mid-session, avoiding context switches to another terminal window.

Pro tip: Shell mode history navigation filters by prefix. Type !git and press the up arrow, and you'll cycle only through previous git commands — making it fast to find and reuse recent shell commands.

Putting it all together

A natural workflow for bigger tasks looks like this: start in plan mode to get aligned on the approach, then Shift+Tab through to autopilot to let Copilot run with it. Drop back into standard mode when you want to steer in real time, and use shell mode whenever you need to quickly check something in your environment without breaking your flow.

Wrapping up

Understanding these modes is the foundation for using Copilot CLI effectively. The right mode at the right time means you stay in control without becoming a bottleneck in your own workflow.

In the next post, we'll look at session management.

More information

GitHub Copilot CLI - GitHub Docs

Allowing GitHub Copilot CLI to work autonomously - GitHub Docs

Autopilot & Plan Modes | github/copilot-cli | DeepWiki

Learn why Minimal APIs often miss OpenAPI response types and how to fix missing 404, 400, and 500 responses using TypedResults and Produces methods.

The page Minimal APIs: Fix missing OpenAPI response documentation appeared on Round The Code.

Async does not mean scalable
6 minutes by Irina Scurtu

Irina argues that async/await frees up threads but does not make the underlying work faster. A database still gets 1,000 queries whether the code awaits them or not. Message queues move pressure from one place to another, and if consumers are slower than producers, debt builds fast. Real throughput improvements come from adding consumers, partitioning work, and fixing the actual bottleneck, whether that is a missing index, an N+1 query, or a rate-limited API.

ReSharper Is Now Available for VS Code and Cursor
sponsored by Jetbrains

Bring 20 years of .NET expertise into your editor. The new ReSharper extension delivers a productivity boost for C#, Razor, Blazor, and XAML – right inside VS Code, Cursor, and other compatible editors. Working with AI-generated code? ReSharper helps you review, refine, and ship production-ready code with confidence. Install this professional tool with a free option for non-commercial use.

Modern mapping with EF Core
15 minutes by Ricardo Peres

Ricardo explains modern mapping techniques in EF Core, including how entities, value types, and primitive collections can be stored in databases. He describes new features such as complex properties, owned entities, JSON storage, table and entity splitting, and shadow or indexer properties. He also shows how to map data from views, SQL queries, and functions, giving developers more flexible ways to design and store data.

How an ASP.NET MVC quirk became a security leak
4 minutes by Bart Wullems

ASP.NET MVC silently removes duplicate filter types when building the filter pipeline, keeping only the most specific one. A global filter loses to a controller-level filter of the same type, with no warning or log entry. Bart points out that this caused a security gap where a stricter permission check was quietly discarded, leaving only the weaker global rule. The fix was setting AllowMultiple to true on the attribute and auditing all filters for similar type collisions.

.NET memory dump analysis with DumpLinq
14 minutes by Anders Pedersen

Memory dumps let you inspect a frozen snapshot of a crashed process before restarting it wipes all evidence. Beyond just finding memory leaks or stuck threads, you can query object state directly using LINQ, turning the dump into a searchable database. Anders shows how this works with two real cases: one traced uneven load balancing to a version mismatch in a client component, another confirmed stuck work items caused by CPU memory reordering.

High performance logging in .NET
6 minutes by Abdul Rahman

Abdul teaches you two powerful .NET techniques designed for high-performance logging in hot paths: the LoggerMessage.Define method and the logging source generator. Both are built into Microsoft.Extensions.Logging and produce the fastest, most memory-efficient logs possible in .NET.

And the most popular article from the last issue was:

• Cleaner switch expressions with pattern matching in C#

At a time when it was almost certain that laptop prices were going to skyrocket due to the impending RAM shortage during the second half of 2026, Apple, of all companies, came out with a $599 laptop that has not just the target audience excited, but also some enthusiasts as well. But it seems as though some of them got a bit too excited for the MacBook Neo.

Many on social media already declared that the $599 MacBook could destroy Windows laptops in the budget segment.

The argument goes that Apple’s entering the $599 tier changes everything, particularly in performance and build quality. But the idea that the Neo will suddenly wipe out Windows laptops in the $600–$800 range may be greatly exaggerated.

Ironically, Apple itself once mocked cheap PCs. During the late 2000s, Steve Jobs openly criticized $500 computers, arguing that Apple would never ship “junk” hardware just to hit a lower price point.

“We don’t know how to make a $500 computer that’s not a piece of junk; our DNA will not let us do that.”

– Steve Jobs to Wall Street analysts in 2008 when asked about low-cost laptops

Well, it seems like Apple fans think otherwise. Sure, times have changed, but it was Apple that deliberately avoided the budget PC market because it wanted to be associated with a premium brand. There is no reason to doubt that Apple’s agenda has changed, as we said earlier.

Adjusted for inflation, $500 from around 2010 would land somewhere in the ballpark of $700 to $750 today. MacBook Neo is even cheaper than the territory Jobs famously dismissed!

Anyway, the question is whether the MacBook Neo truly threatens Windows laptops in the $600 market, as the internet hype suggests. Industry analysts believe that it’s not as straightforward as the “Windows is doomed” narrative.

The MacBook Neo targets a new buyer group, but it will not automatically replace Windows laptops

Technology analyst Ben Bajarin, CEO of market research firm Creative Strategies, says the conversation around the MacBook Neo is missing an important detail: the device is aimed at a very specific type of buyer.

“Given the target customer for this, RAM is not an issue, and any consumer who scrutinizes their RAM needs is not the target customer for this product,” Bajarin said, adding that the device is primarily aimed at entry-level consumers, education buyers, and students.

If it wasn’t clear already, the Neo is not designed for power users, developers, or enterprise environments. It is a basic computing device meant for people who want a simple laptop for everyday tasks like browsing, streaming, and light productivity.

The $600–$800 laptop segment already has a very well-defined buyer profile. They typically keep their devices for many years and rarely compare processor benchmarks or memory configurations.

More importantly, many people who have historically wanted a Mac but could not afford one did not automatically buy a new Windows laptop instead. A large portion of that demand has long been served by refurbished MacBooks, older MacBook Air models, or discounted previous-generation Macs sold through third-party retailers.

Apple itself has supported this behavior through its official refurbished store, where older MacBook models often sell in the same $600–$800 price range. So, a budget Mac market already existed long before the Neo.

But that’s not to say that Windows PCs are completely safe. People who had no choice but to buy budget PCs would definitely find the Neo attractive, considering the Apple branding and unmistakably good design and colors.

However, Bajarin believes PC OEMs will respond quickly, because they have no reason to let Apple take share uncontested. Windows laptops in this price range already exist in large numbers, often offering 16GB of RAM, 512GB SSDs, and upgradeable storage for between $499 and $699.

Unlike Apple, PC manufacturers have been building machines for this segment for decades, and they can easily adjust configurations and pricing to remain competitive. Now, that’s good news for customers, as we’ll get better designs and metal builds in even budget Windows PCs.

But if you strictly want a laptop for $600 and you expect the MacBook Neo to do the kind of stuff that a $600 Windows PC can do, then you have mistaken the Neo’s biggest limitation.

The 8GB RAM limitation could be the biggest weakness of MacBook Neo

Andrew Mark David and JustJoshTech, both of whom use MacBooks for their regular work, are among the honest YouTubers out there. Their unbiased, unpaid initial impressions of MacBook Neo clearly explain why it isn’t a big deal, as the mainstream media hype tells.

Let’s start with the processor used on the Neo. Apple’s A18 Pro is a seriously impressive piece of silicon, but the following CPU score from JustJoshTech clearly tells the issue:

The single-core performance is class-leading, but the multi-core is what determines the overall performance of the laptop, as most applications are tuned to use a number of cores efficiently. Here, the MacBook Neo ranks the lowest, even below Windows 11 PCs. It’s only as good as the 6-year-old M1 MacBook Air, which was honestly good for its time, but not anymore, because 8GB RAM is just not enough.

The latest MacOS, with the fancy Liquid Glass UI, uses around 4GB of RAM, so any application you run would eat into the rest of the 4GB RAM in the Neo. 6 years was a long time ago, and applications have gotten a lot more feature-rich.

Apple has handled lower memory configurations through aggressive SSD swapping. However, earlier 8GB MacBook Air models showed that heavy browser workloads could experience slowdowns compared to 16GB versions, due to the system constantly swapping data.

Don’t get me wrong, the MacBook Neo would be perfect for anyone who occasionally opens their laptop to fill out a form, 3 to 4 browser tabs, Office documents, social media, etc, all single core stuffs. But installing multiple apps, or games, or transferring files isn’t going to be its forte.

Remember that the 256GB base storage in the Neo may get used up quickly in about 6 to 12 months. Once the SSD gets crowded, the overall responsiveness can suffer. Apple does offer a 512GB upgrade for $699, but that immediately pushes the MacBook Neo to a different competitive landscape.

Windows laptops to buy instead of MacBook Neo

There are countless Windows PCs in the $600 to $800 segment, and the best ones are almost always on sale. So the right place to start would be to check sales prices and deals.

This Dell Inspiron 14 Plus is a great all-rounder that’s much more powerful than the Neo, owing to its good multicore performance and double the RAM at the same price as the Neo during sales, and luckily, it’s almost always on sale.

You can, of course, argue that the Neo can reach a $499 price tag with an educational discount, so here’s one from HP. The OmniBook 5 has an OLED display, which even the MacBook Pro doesn’t have, making it an easy recommendation for media consumption.

Sure, you may have to do some research before buying these, but if you do, you’ll get a powerful Windows PC with better RAM, storage, display, ports, keyboard, trackpad, more apps, and games (which is an understatement), that will last for years to come, and you can even upgrade or repair for cheap.

Not to mention the situation that Microsoft put itself in. While enraged power users criticize the company about AI, Windows 11 is now as smooth and reliable as ever. But Microsoft even promised to make the OS better this year.

As for hardware, this is the best time to bring back Microsoft’s Surface Go lineup, possibly powered by the Snapdragon X2 series for great performance and battery life.

The MacBook Neo is interesting, but Windows PCs are far from doomed

The MacBook Neo is an interesting product for Apple. It lowers the barrier to entry for people who have always wanted a Mac but could never justify paying $1,000 or more for one.

Of course, Apple’s target market for the MacBook Neo does not care about hardware specifications. They just wanted an Apple laptop to browse, stream, and edit documents, and that’s the only market that Apple is going for.

But the internet hype claiming that it will destroy the Windows laptop market does not hold up. The $600–$800 laptop segment has been one of the most competitive areas of the PC industry for decades, and Windows OEMs have been refining machines for that price range long before Apple decided to enter it. More importantly, the Neo simply formalizes a budget Mac market that already existed.

If anything, the MacBook Neo may actually benefit consumers the most. Apple’s entering this segment will likely push PC manufacturers to build even better budget laptops, which means buyers will have more options and better hardware across the board.

So yes, the MacBook Neo will sell well. It may even help Apple grow its Mac sales significantly. But the idea that it will suddenly wipe out Windows laptops in the budget segment is more internet hype than market reality.

The post Apple’s $599 MacBook Neo may challenge Windows 11 PCs, but it won’t dent market share much appeared first on Windows Latest

Microsoft Build 2026, the premier Enterprise conference for Developers, Data & AI Builders, & Solutions Architects is back… this year in San Francisco, CA! 

If you are interested in attending in-person in San Francisco OR if you’d simply like to join the FREE virtual/digital streaming experience, please take the time to register ASAP!

Over two days, you’ll get hands-on with cutting-edge tools, dig into real code, and connect with the engineers shaping the future of AI. Request to attend for a chance to: 

• Get trusted guidance for secure, reliable deployments. 
• Explore real-world customer stories. 
• Take part in deep-dive technical sessions and hands-on labs. 
• Engage with product and engineering leadership. 
• Network with your peers and technology leaders. 

Plus, hear from:

• Satya Nadella, Chairman and CEO  
• Jared Palmer, VP of CoreAI, SVP of GitHub, 
• Scott Hanselman, VP, Member of Technical Staff, Microsoft/GitHub 
• Simon Willison, AI Researcher and Creator, Datasette
• Chip Huyen, Building at Stealth
• Priyanka Sharma, CXO, Thiink Inc.

Spots are limited. Act fast!

• Dates: June 2-3, 2026
• Location: Fort Mason Center, San Francisco, CA
• Registration: https://build.microsoft.com/en-US/home
• Frequently Asked Questions: https://build.microsoft.com/en-US/get-help

Why I built it

After refactors, Angular apps often end up with unused dependencies, dead exports, and lint drift. I wanted a single place in VS Code to run the usual code-quality tools and jump straight to the issues – without remembering CLI commands or switching to the terminal.

So I built Angular Code Quality Toolkit: a small VS Code extension that runs depcheck, ts-prune, ESLint, and stylelint from the editor and shows everything in the Problems panel and as squiggles in the code.

What it does

• Run depcheck — Finds unused and missing npm dependencies; results show in Output and Problems.
• Run ts-prune — Finds unused TypeScript exports; uses tsconfig.app.json when present.
• Run ESLint — Runs your workspace npm run lint and shows diagnostics in the editor (with a nudge to migrate from TSLint if needed).
• Add ESLint to Angular project — One-click run of ng add @angular-eslint/schematics.
• Run stylelint — Lints CSS/SCSS (uses your npm script or a default glob).

All results go to one Angular Code Quality output channel and into View → Problems plus inline squiggles, so you can fix issues file-by-file.

How to use it

1. Install from the VS Code Marketplace or search Angular Code Quality Toolkit in Extensions.
2. Open an Angular project (folder with package.json).
3. Ensure the tools are available in that project (npm install --save-dev depcheck ts-prune, plus a "lint" script and optionally stylelint).
4. Ctrl+Shift+P (or Cmd+Shift+P) → run Angular Code Quality: Run depcheck (or ts-prune, ESLint, stylelint).
5. Open Problems and the Angular Code Quality output channel; click an issue to jump to the file and line.

Extension + CI, not either/or

The extension is for fast feedback while you code. For team-wide enforcement, use CI (e.g. GitHub Actions) and git hooks (e.g. husky + lint-staged) with the same tools. The README has a sample GitHub Actions workflow you can copy.

Links

• VS Code Marketplace: Angular Code Quality Toolkit
• GitHub: github.com/Arul1998/angular-code-quality-toolkit

If you try it on a large Angular app or monorepo, I’d love to hear what works and what you’d improve.