Fixed

• ACP terminal-auth passes correct arguments to login
• Arrow and special keys work reliably when held down
• Slash command ghost text appends correctly

Unhandled exceptions in ASP.NET Core can expose sensitive data. Learn when it happens, why it's dangerous, and how to fix it.

The page Are exceptions exposing vulnerabilities in your .NET App? appeared on Round The Code.

Introducing the Codex app for macOS—a command center for AI coding and software development with multiple agents, parallel workflows, and long-running tasks.

T-Mobile is laying off 393 workers in Washington as part of a new round of cuts, according to a filing with the state Employment Security Department released Monday morning.

More than 200 different job titles are impacted, according to the filing, including analysts, engineers and technicians, as well as directors and managers.

The cuts targeted nearly 210 senior- and director-level employees, plus seven employees with vice president or senior vice president titles. They include a senior VP of talent and four VP of legal affairs roles.

Affected employees worked at the company’s Bellevue headquarters; data centers in Bellevue and East Wenatchee; and at stores and other facilities in Bothell, Bellingham, Woodinville, Spokane Valley and elsewhere.

The layoffs were attributed to “changing business needs,” according to the WARN filing signed by Monica Frohock, senior director of the Magenta Service Center.

“These facilities are not being closed,” the notice stated. “The layoffs are not due to relocation or contracting out employer operations or employee positions, but it is possible that some work currently done by these employees may at some point be done by others.”

Affected employees were given 60-days’ notice and the departures are expected to take effect April 2.

T-Mobile employed about 70,000 people as of Dec. 31, 2024. The company has nearly 8,000 workers in the Seattle region, according to LinkedIn.

The cuts come as the Seattle area is being hit by thousands of tech-related layoffs, including job losses at Amazon, Expedia, Meta and other companies.

T-Mobile, the largest U.S. telecom company by market capitalization, laid off 121 workers in August 2025. In November, former Chief Operating Officer Srini Gopalan replaced longtime leader Mike Sievert as CEO.

T-Mobile’s stock is down nearly 20% over the past 12 months. The company reported revenue of $18.2 billion in the third quarter, up 9% year-over-year, and added 1 million new postpaid phone customers.

Verizon, another telecom giant, laid off approximately 165 employees in Washington in November.

Amazon is laying off 2,198 employees across Washington as part of the company’s latest corporate workforce reduction, according to a new filing released Monday by the state Employment Security Department.

A detailed list included with the Washington state filing shows that software development roles account for the largest share of the layoffs, with engineering management, program management, and technical product roles also hit hard.

In total, more than half of the cuts impact Amazon’s core product and engineering organizations. The remaining positions span business intelligence, sales, marketing, infrastructure, QA, HR, design, and other support functions. Senior- and principal-level employees were also affected.

A majority of the cuts — more than 1,400 — impact workers in Seattle, with more than 600 in nearby Bellevue, where Amazon has been expanding its office footprint.

The cuts are part of Amazon’s company-wide layoffs announced last week that impact 16,000 corporate employees globally. Combined with a 14,000-worker layoff in October, it’s the largest corporate workforce reduction in the company’s history.

As part of the October cuts, Amazon laid off 2,303 employees in Washington state. Between the two layoffs, Amazon has laid off more than 4,500 corporate workers in Washington state in less than a year.

Software engineers were also the largest group of employees affected by the cuts in October. Corporate support and commercial functions were hit harder in that round, which included engineering roles but also targeted legal, tax, and ad sales positions that are largely absent from the new list released Monday. The October cuts also hit Amazon’s gaming division, while this latest round is focused more squarely on the core technology organization.

The company has made several additional, smaller workforce reductions in recent years as it seeks to streamline operations. In a memo to employees sent Wednesday, Amazon senior vice president of people experience and technology Beth Galetti said the company is “reducing layers, increasing ownership, and removing bureaucracy.”

The specific job titles in the latest Washington state filing align with that goal, particularly in the company’s technical teams. The list includes a significant number of “Manager III” and “Senior Manager” roles within software and product teams, suggesting Amazon is axing layers of oversight, not just reducing individual contributor headcount.

Amazon noted in the filing that employees who secure internal transfers before their separation dates will not ultimately be laid off. Separations are scheduled to begin April 28 and continue through late June, according to the filing.

Tech pullback in Seattle

Amazon employs roughly 50,000 corporate workers in the Seattle region, which serves as its primary headquarters. The company also laid off 27,000 workers globally in 2022-2023.

The latest cuts come amid concerns about Seattle’s tech-heavy economy as other companies trim headcount.

• GeekWire reported Monday that T-Mobile is laying off nearly 400 workers.
• Expedia and Meta laid off hundreds of workers last month.
• Microsoft laid off more than 3,200 employees in Washington state last year, part of broader cuts that impacted 15,000 people globally. 

Many corporations are slashing headcount to address pandemic-fueled corporate “bloat” while juggling economic uncertainty and impact from AI tools.

The Seattle area lost 12,900 jobs last year across all sectors — the first time the region has experienced an annual decrease of jobs since 2009, according to The Puget Sound Regional Council.

Amazon implemented a five-day return-to-office policy for corporate employees last year — a move that drew pushback from some workers but a friendlier reception from small businesses surrounding Amazon’s office buildings.

Jon Scholes, president of the Downtown Seattle Association, said in a statement last week that a “workforce change of this scale has ripple effects on the community.”

The broader layoffs may also impact Seattle’s commercial real estate market, which continues to struggle with record-high vacancy rates.

Amazon is also laying off about 400 workers in Washington state as part of its decision to close all Amazon Go and Amazon Fresh stores nationwide. Those cuts are separate from the corporate layoffs.

Modern engineering work rarely lives in a single file. Real systems evolve across years of incrementally layered decisions—some good, some accidental. A single feature request (“Add tagging to notes,” “Refactor the validation layer,” “Support a new consumer on our API”) often touches controllers, domain models, repositories, migrations, tests, documentation, and deployment strategy.

Copilot’s agentic capabilities don’t replace your judgment in these situations—they amplify it. When used well, Copilot becomes a partner in system design, refactoring, modernization, and multi-file coordination.

This guide focuses on architecture-aware, multi-step workflows used every day by staff engineers, but written to be accessible for earlier-career engineers who want to understand how senior engineers think—and how Copilot can accelerate their own growth.

It draws on four GitHub Skills exercises (linked below), and builds toward a complete, real-world scenario: extending a small modular Notes Service with a tagging subsystem, refactoring a validation layer, designing a safe migration, and modernizing tests.

---

Before you start

You’ll get the most out of this guide if you have:

• GitHub Copilot with agent mode enabled
• Some familiarity with service-layer architectures (Node, Python, Go—language doesn’t matter
• Copy a GitHub Skills exercise template to your handle or organization (use the green “Copy Exercise” button)
• A willingness to let Copilot propose solutions—and the judgment to inspect and challenge them

If you’re earlier in your career, don’t worry. Each section explains why these patterns matter and how to practice them safely.

---

Using Copilot for system design and decomposition (not just scaffolding)

Senior engineers rarely begin by writing code. They begin by identifying boundaries: domain logic, data access, interfaces, and how modules should interact.

Copilot agent mode can help by revealing structural issues and proposing architectures.

Prompt:

Analyze this service and propose a modular decomposition with domain, infrastructure, and interface layers.

Identify anti-patterns, coupling issues, and potential failure points.

You’ll typically get back:

• Proposed module boundaries
• Cross-layer coupling concerns
• Async/transaction pitfalls
• Duplication or tight weaving of responsibilities
• Testability and observability implications

This transforms Copilot from an autocomplete tool into a design reviewer.

You can push further by asking it to compare architectures:

Compare hexagonal architecture vs. layered architecture for this codebase.

Recommend one based on the constraints here. Include tradeoffs.

Want to try it yourself? Use these proposals as starting points.

Building a modular service using agentic workflows

Once boundaries are defined, Copilot can coordinate changes across modules.

Prompt:

Implement the domain, controller, and repository layers as distinct modules.

Use dependency inversion to reduce coupling.

Document assumptions and contracts for each module.

Copilot will typically generate:

• Domain model interfaces
• Repository abstractions
• Controller logic calling domain services
• A short Markdown summary describing each module

For earlier-career engineers, this provides exposure to real engineering patterns. For senior engineers, it provides leverage and reduces boilerplate overhead.

Feature work with architectural awareness (example: tagging subsystem)

Adding a tagging subsystem is a deceptively simple request with meaningful architectural implications.

Even this single feature forces decisions across the system: 

• Data modeling: embedded tags vs. normalized tables vs. many-to-many relationships
• Search behavior: how tags affect indexing, filtering, and relevance
• API contracts: whether tags are first-class resources or an implementation detail
• Validation boundaries: where constraints and invariants are enforced
• Migration and rollout: additive vs. breaking changes and rollback strategy

Before touching code, ask Copilot to map the impact.

Prompt: 

Propose the architectural changes required to add a tagging subsystem.

Identify migration needs, cross-cutting concerns, caching or indexing implications, and potential regressions.

Copilot may identify:

• Tag–note relationships (one-to-many or many-to-many)
• Migration strategy
• Impact to search logic
• Required test updates
• Changes in validation logic
• Implications on external API consumers

This is the staff-level lens that Copilot can help junior developers adopt.

Then implement it:

Implement the tagging domain model, schema changes, repository updates, and controller logic.

Update tests and documentation. Show each change as a diff.

Example output (simplified)

Migration example:

ALTER TABLE notes ADD COLUMN tags TEXT DEFAULT '[]';

Domain model example:

export interface Tag {
  id: string;
  label: string;
}

export interface Note {
  id: string;
  title: string;
  body: string;
  tags: Tag[];
}

Controller update (partial):

await noteService.addTag(noteId, { label: req.body.label });

This is where agent mode shines: coordinating multiple files with consistent intent.

Schema migrations and safe rollout strategies

At senior levels, the hardest part isn’t writing SQL. It’s designing a change that is:

• Backward compatible
• Reversible
• Safe under load
• Transparent to dependent systems

Ask Copilot to reason about this:

Prompt:

Generate an additive, backward-compatible schema migration to support the tagging subsystem.

Describe the rollback plan, compatibility window, and expected impact to existing clients.

This forces Copilot to consider:

• Mon-breaking additive fields
• Optional fields vs. required fields
• Whether a dual-read or dual-write strategy is needed
• Safe rollback procedures
• API versioning implications

If you’re earlier in your career, this offers lessons on how safe migrations are designed. And if you’re more experienced, this gives you a repeatable workflow for multi-step schema evolution.

Advanced refactoring with agentic workflows

Let’s perform a real cross-module refactor: extracting validation out of controllers into a domain service.

Prompt:

Create a step-by-step refactor plan to extract validation logic into a domain service.

Identify affected modules and required test updates.

Copilot may output something like:

1. Introduce domain validationService
2. Move validation logic from controller to service
3. Update controllers to use new service
4. Update repository logic where validation assumptions leak
5. Update domain tests
6. Update integration tests

Execute in incremental steps

Prompt:

Execute steps 1–3 only. Stop before controller rewrites.

Provide detailed diffs and call out risky areas.

This is a low-blast-radius refactor, modeled directly in the IDE.

Modernizing test strategy

Instead of asking Copilot “write tests,” ask it to assess the entire suite.

Prompt:

Analyze the current test suite and identify systemic gaps.

Recommend a modernization plan including contract, integration, and domain-layer tests.

Then implement contract tests:

describe("NotesRepository contract", () => {
  test("create + fetch returns a fully hydrated note object", async () => {
    const note = await notesRepo.create({ title: "Test", body: "…" });
    const fetched = await notesRepo.get(note.id);

    expect(fetched).toMatchObject({ title: "Test" });
    expect(fetched.id).toBeDefined();
  });
});

This elevates testing into an architectural concern.

A complete end-to-end workflow

Bringing it all together, here’s a real sequence you might run with Copilot:

1. Ask Copilot to analyze the existing architecture: identify hazards, modularization opportunities
2. Define module boundaries: domain, repository, controller layers
3. Add tagging subsystem: architectural assessment to implementation to tests to doc updates
4. Create a backward-compatible migration: additive schema to rollback plan
5. Perform a targeted refactor: validation layer extraction
6. Modernize tests: contract + integration + domain tests

This workflow is architecturally realistic—and a model for how Copilot becomes a system-level collaborator.

What agent mode is not for

It’s important to clarify that agent mode is not ideal for:

• Altering domain invariants without human review
• Redesigning cross-service ownership boundaries
• Replacing logic driven by institutional knowledge
• Large sweeping rewrites across hundreds of files
• Debugging deep runtime issues

Copilot should support your decision-making, not replace it.

Where to go next

Here’s where GitHub Skills comes in—not as “beginner content,” but as a set of guided, self-contained labs that reinforce the patterns above. 

Even senior engineers will benefit: These exercises are structured so you can reliably recreate complex workflows and test Copilot’s behavior in controlled environments.

The post How to maximize GitHub Copilot’s agentic capabilities appeared first on The GitHub Blog.