Week 5: Microsoft Office Copilot and VSCode

Learning objectives

By the end of this week, you will be able to:

1. Explain, in plain terms, what Microsoft Copilot does inside Word, Excel, PowerPoint, and Outlook.
2. Use your screen reader's heading navigation or landmark and region navigation to explore a Copilot pane or chat panel in an Office app.
3. Draft, revise, and iterate on a short document or email with Copilot, using only the keyboard.
4. Describe realistic use cases for Copilot in each of the four Office apps covered this week.
5. Explain what VS Code is and what its dedicated screen reader mode is meant to do.
6. Open VS Code's command palette with Ctrl+Shift+P (or Cmd+Shift+P on a Mac) and use it to search for a command or setting.
7. Open VS Code's integrated terminal and run a simple text command, and open, read, and edit a .md, .json, or .py file with a screen reader.
8. Honestly assess the accessibility of an AI feature by testing it yourself, rather than assuming it works a certain way.

Lesson

This week introduces two very different kinds of AI-integrated software you are likely to meet at work: an AI assistant built directly into everyday office programs, and a professional code editor used across the technology industry and beyond. The two halves of this lesson do not depend on each other, so you can read them in either order, but together they widen your picture of where AI now shows up in ordinary software, far beyond a single chat window.

What Microsoft Copilot Is Inside Word, Excel, PowerPoint, and Outlook

Microsoft Copilot is an AI assistant built directly into Microsoft 365 applications, including Word, Excel, PowerPoint, and Outlook. Rather than being a separate program you open on its own, Copilot appears from inside the app you are already using, aware of the file currently open in front of you: the document, the spreadsheet, the presentation, or the email. You can ask it, in plain language, to draft new content, summarize existing content, analyze data, or answer a question about what is already on the page.

Conceptually, Copilot is built on the same kind of large language model technology as the standalone AI chat assistants you have already learned to use in earlier lessons. The core skill of writing a clear, specific request applies here just as it did there. What is different is context: because Copilot is built into the app, it can often see the content you already have open, with your permission, which means it can summarize a report you already wrote, answer a question about numbers already sitting in a spreadsheet, or suggest a next sentence for an email you are drafting, instead of only generating brand-new text from nothing.

Copilot is not one single feature that behaves identically everywhere. Each Office application uses it a little differently, matched to what that application is for: word processing in Word, numbers and formulas in Excel, slides in PowerPoint, and email in Outlook. The next sections walk through each of those four applications in turn, along with a shared, honest look at what its accessibility is actually like for a screen reader user, rather than what a product description claims.

Finding and Opening Copilot With a Screen Reader

Exactly how you open Copilot in a given app, which button, menu item, or search box currently leads to it, changes over time as Microsoft updates its software, and can differ slightly between apps. Because of that, this lesson will not claim one fixed path is permanent. Instead, it teaches a method that stays useful no matter how the interface changes: look for a Copilot button on the toolbar or ribbon, or use the app's own search box, often labeled something like "search" or "tell me what you want to do," and type "Copilot" to find and activate it.

Once Copilot is open, it typically appears as a sidebar or pane along one edge of the window, with an edit field for your request and an area where the response appears. If you are not sure where that pane is or how it is structured, use your screen reader's heading navigation or its landmark and region navigation to explore it: many modern Office panes are marked up with headings or labeled regions specifically so assistive technology can locate and describe them. Arrowing through headings, or jumping between regions, is often faster and more reliable than tabbing through every control one at a time.

If you cannot find Copilot at all, or your screen reader does not announce anything useful when you activate it, do not assume the feature is broken or unavailable. Search the application's own Help for "Copilot," or check Microsoft's current accessibility documentation, updated far more often than any single lesson could be. Treating a tool's own search and help features as your first stop, rather than a memorized set of steps, is a habit worth carrying into every new AI tool you meet.

Copilot in Word: Drafting and Revising a Document

Inside Word, Copilot is most useful for exactly the kind of writing work a coworker or a standalone chat assistant might help with, except it happens right inside the document you are already working in. A realistic request might be asking Copilot to draft a first version of a report from a short instruction, such as "draft a three-paragraph report summarizing our team's progress this month, in a professional tone." Copilot can also summarize a long document you did not write yourself, rewrite a paragraph in a different tone, or answer a direct question about the document's content, such as "what are the three main points of this section?"

A practical workflow looks like this: open Copilot's pane, type a specific request the same way you would with any AI chat tool, and wait for the draft to appear, either inserted directly into your document or shown first inside the Copilot pane for you to review. Read the draft carefully using your screen reader's continuous reading command, sometimes called Say All, before you accept it. If something is off, treat the draft the way you would treat any first attempt from an AI tool: ask for a revision in plain language, such as "make it shorter" or "make the tone more formal," rather than starting completely over.

Once you accept a draft, it becomes ordinary text inside your Word document, and you can edit it using the same keyboard commands and screen reader techniques you already use for any Word document. Copilot's role ends at the draft; your judgment, editing, and final approval still matter, exactly as they do with every other AI writing tool this course has covered.

Copilot in Excel: Formulas and Summarizing Data

Excel is built around numbers arranged in a grid, which can be one of the more challenging layouts for a screen reader user to work through cell by cell. Copilot in Excel offers a different way in: instead of asking you to read every cell yourself, you can ask it to explain what an existing formula does, help you write a new formula for a specific goal, such as adding up a column only when it meets a certain condition, or summarize what the data shows in plain language, for example, "what trends do you see in this data?" or "which month had the highest total?"

This plain-language summarizing feature is worth paying particular attention to, because it can genuinely change how efficiently you work with a spreadsheet. Reading dozens or hundreds of individual cells one at a time to find a pattern is slow. Asking Copilot to describe the pattern in a sentence or two, readable with Say All, can be considerably faster, when it works well. Whether it works well for your specific spreadsheet and screen reader is worth testing directly rather than assuming, since spreadsheet structure varies enormously from one file to the next.

As with Word, treat any formula or summary Copilot produces as a draft to verify, not a final answer to trust blindly. A formula that looks correct in a chat response can still reference the wrong column or make an assumption about your data that does not hold. Check a Copilot-suggested formula's actual result against numbers you can verify another way before relying on it for anything important, such as a report you will hand to a supervisor.

Copilot in PowerPoint: Drafting an Outline

In PowerPoint, Copilot's most broadly useful feature for a screen reader user is drafting text: give it a short description of your topic and audience, and ask it to draft an outline of slide titles and bullet points, or generate a full first draft from a topic description or an existing Word document. This is useful groundwork, since it produces the text content of a presentation, the part that matters most when it is read aloud rather than looked at.

PowerPoint's Copilot features also include visual design suggestions, such as automatically rearranging or restyling slide layouts. Here is an honest caution worth stating plainly: those design suggestions are primarily visual, aimed at how a slide looks on screen, and they may add limited practical value for you as a screen reader user, since a rearranged layout does not change what content is present or how it reads aloud. The text-drafting side of Copilot in PowerPoint, generating and revising the actual words on each slide, is the part most directly useful to you, and it is worth focusing your practice there.

As with the other Office apps, review any Copilot-drafted slide content using your screen reader before you consider a presentation finished. Read through the outline slide by slide, confirm the bullet points say what you intended, and revise anything that feels generic or off-target with a plain-language follow-up request.

Copilot in Outlook: Drafting and Replying to Email

In Outlook, Copilot can draft a reply to an email, summarizing the key points of a long thread so you do not have to read every message in full, or drafting a brand-new email from a short set of bullet points you provide. It can also adjust tone, for example turning a blunt first draft into something more formal, or a stiff first draft into something warmer, on request.

A typical workflow starts with opening the email you want to respond to, invoking Copilot from within that message, and asking for a draft reply, such as "draft a reply thanking them for the update and asking for the report by Friday." Review the draft with your screen reader before sending anything. This is exactly the same iteration skill you have already practiced with other AI writing tools: read the first draft, decide what needs to change, and ask for that change directly in plain language, rather than assuming the first version is ready to send.

Email carries real consequences once it is sent, so be especially deliberate about review here. Reading a Copilot-drafted reply in full with Say All before pressing send protects you from an error, a wrong name, or a tone you did not intend.

Copilot's Accessibility: Test It Yourself

Here is the honest, important part of this half of the lesson. Microsoft has generally invested in the accessibility of its core Office applications for a long time, and that investment tends to give Word, Excel, PowerPoint, and Outlook a more mature accessibility foundation than some newer, AI-first tools that have not had as many years of testing and fixes behind them. Copilot panes are generally built using standard controls, which tends to help.

That said, none of this guarantees a smooth experience every time. Exactly how clearly a pane's heading is announced, whether new response content is announced automatically or requires manual navigation, and whether every button carries a clear label, can vary between applications, versions, and updates. Do not take this lesson's description, or any company's marketing claim, as the final word on how well a feature works with your own screen reader today.

The reliable approach is to test it yourself. Open Copilot in one Office app, ask it a simple, low-stakes request, and pay close attention: is the pane's heading announced when it opens, is new content read automatically or does it need manual navigation, are buttons labeled clearly? None of these outcomes mean you did something wrong; they are data about how that feature behaves right now, worth writing down as you build a reliable, personal picture of which AI features are worth relying on.

What VS Code Is

Word processors and spreadsheets are software nearly everyone touches at work. Code editors are a narrower tool, but one worth knowing regardless of whether you ever write a full computer program, because AI increasingly shows up inside them too, and because comfort with a widely used editor is a broadly useful, resume-worthy skill on its own.

Visual Studio Code, usually just called VS Code, is a free code editor made by Microsoft. A code editor is a program built for writing and organizing text files that a computer can run, such as web pages, small automation scripts, or configuration files. VS Code is one of the most widely used code editors in the world, used by professional developers, students, hobbyists, and increasingly by non-programmers who use AI tools to write simple scripts or edit structured files, the same kinds of files you will practice with later in this lesson.

Because VS Code has been developed and maintained for many years, with a large community of contributors, its screen reader support has had considerably more time to mature, get tested, and get fixed, compared to newer, AI-first tools still working out early accessibility problems. That does not mean VS Code is a perfect experience; no software is. It means you are starting from a sturdier accessibility foundation. This week, as with the Office half of the lesson, the habit to build is the same: check how well a tool actually works with your own screen reader before you judge it by its feature list alone.

VS Code's Screen Reader Mode and Accessibility Settings

VS Code includes a dedicated screen reader mode, a group of accessibility-related settings, and audio cues that can play at certain moments, such as when a line contains an error, to give you information without requiring you to visually scan the screen. The general idea behind a "screen reader mode" in an application like VS Code is that some features that make sense for a sighted user working with a mouse, such as certain animations, popups, or dense visual layouts, are turned off or changed when the application detects you are using a screen reader, so that what your screen reader announces stays clear, predictable, and not cluttered with extra information you do not need.

For example, imagine two people each open VS Code for the first time. A sighted user might notice a small icon change color to signal an error on a line of code. A screen reader user relying only on that visual cue would miss it entirely. This is exactly the kind of gap VS Code's dedicated accessibility features are built to close: an audio cue or a screen-reader-announced message can carry the same information the color change carries visually, so you are not missing anything just because you cannot see a color shift on the screen. Whether a specific cue is currently on by default, or needs to be turned on through the accessibility settings, is worth checking for yourself, using the method described next, rather than assuming.

Because VS Code, like almost all modern software, is updated frequently, this lesson will not tell you a single fixed menu path to turn on screen reader mode or to open the accessibility settings, since that exact path can change from one version to the next, and a fixed instruction that was accurate when this course was written could be wrong by the time you read it. Instead, the next section teaches a method that stays reliable no matter how the menus change.

The Command Palette: One Reliable Keystroke

That method centers on VS Code's command palette. The command palette is a searchable list of essentially every command the application can perform, opened by typing its name or a related word rather than hunting through nested visual menus. Here is one of the few interface details in this entire course stated as a plain fact rather than as something to explore for yourself: the keyboard shortcut to open the command palette is Ctrl+Shift+P on Windows and Linux, or Cmd+Shift+P on a Mac. This shortcut has stayed stable for years and is safe to rely on directly, unlike almost everything else in this lesson, because so many existing habits, tutorials, and extensions depend on it staying the same.

Once the command palette is open, your screen reader should announce an edit field where you can type. Type a keyword such as "accessibility" or "screen reader," and the palette filters its list down to matching commands in real time, which your screen reader will announce as you arrow through them. Press Enter on the command you want to activate it.

This same search-based approach also finds the accessibility settings area, which holds options such as whether certain audio cues are turned on and how verbose some announcements are. Rather than memorizing a settings menu path that could change, open the command palette, search a word like "accessibility" or "settings," and let VS Code's own search bring you to the current, correct location.

This search-based habit is worth learning well, because it is a durable strategy that applies far beyond VS Code: when you are not sure exactly what an interface currently offers, do not guess. Explore. Search. Ask the application itself, using its own built-in tools, rather than relying only on a static list you memorized once. In VS Code's case, the command palette is that built-in tool, and it is the single most useful skill in this half of the lesson, because it applies just as well to accessibility settings as it does to any other feature you might need to find later.

AI Extensions Inside VS Code

An extension is an add-on: a separate small piece of software you can install into VS Code to give it a new feature it did not have by default. VS Code itself ships with a solid set of core features, but its real power for many users comes from its enormous library of extensions, covering everything from support for additional programming languages, to spelling and grammar checking, to, relevant for this lesson, AI coding assistance. Installing an extension is similar in spirit to installing an app on a smartphone: the core software does a lot on its own, but individual add-ons layer specific new capabilities on top of it.

GitHub Copilot is one of the best-known AI extensions for VS Code, and despite the shared name, it is a separate product from the Microsoft Copilot covered earlier in this lesson, built specifically for coding rather than Office documents. At a conceptual level, it is an AI coding-suggestion tool: as you type, it watches what you have written and suggests what might come next, a single line or a larger block, based on patterns learned from existing code. You can accept a suggestion, ignore it, or ask it to try again. Some AI extensions, GitHub Copilot included, also offer a separate chat panel, where you can type a plain-language question about your code and get a plain-language answer back, similar to a standalone AI assistant, but aware of the file you currently have open.

GitHub Copilot is not the only AI extension available for VS Code, and this course expects that landscape to keep changing. Extensions connect Claude directly into VS Code too, offering similar suggestion and chat capability from a different AI provider, and new AI extensions appear regularly as the field moves quickly. The underlying concept stays the same across all of them: an extension adds AI capability into your editor, as inline suggestions, a chat panel, or often both.

How Well AI Extensions Work With a Screen Reader: Test Before You Trust

Here is the honest, important part of this half of the lesson, matching the same habit built around Copilot earlier. An AI extension like GitHub Copilot or a Claude extension adds real value to many sighted developers, but exactly how well each one is announced by a screen reader can vary, sometimes a great deal, and it can change from one extension update to the next. An inline code suggestion, for example, appears visually as faint, grayed-out text right where your cursor is; whether your screen reader announces that suggestion clearly, announces it in a confusing way, or does not announce it at all until you take a specific action, depends on the extension, the version, and sometimes on VS Code's own settings for how it exposes that content to assistive technology.

Before you build any real workflow around an AI extension, install it, turn on your screen reader, and deliberately explore: type a few lines of test code, notice whether and how a suggestion gets announced, try the chat panel if the extension has one, and use your screen reader's list of interactive elements, sometimes called an elements list, or its landmark and region navigation, to check whether the chat panel's content is exposed the way an ordinary chat window would be.

Picture a concrete testing session. You install an AI extension, open a small text file, and begin typing a simple line of code. A sighted colleague might see gray suggestion text appear instantly after every few keystrokes. Your job, with your own screen reader running, is to notice what actually happens: does it say anything when the suggestion appears, does it stay silent until you press a specific key, or does it announce something confusing? None of these outcomes means you did something wrong; they are data about how that extension currently behaves, worth writing down.

If an inline suggestion is not announced well, that does not necessarily mean the extension is unusable. Many AI extensions offer a keyboard shortcut to request that the current suggestion be read aloud, or a way to move focus to it, precisely because designers know inline suggestions can be an accessibility challenge. Use the command palette to search words like "copilot" or "suggestion" for current commands, rather than assuming a fixed shortcut, since extensions update on their own schedule, separate from VS Code itself.

The chat-panel style of AI extension tends to be considerably more predictable for a screen reader user than the inline-suggestion style, because a chat panel is structurally similar to conversational AI interfaces you have already practiced with: you type a question, and a block of text comes back, readable with Say All. If you are new to AI extensions, beginning with an extension's chat panel, rather than leaning first on inline suggestions, is a reasonable, honest recommendation based on how these tools tend to behave.

The Integrated Terminal

VS Code includes an integrated terminal: a text-based command-line area built directly into the editor, so you do not have to switch to a separate application to run commands. A terminal, in general, is a place where you type text commands and the computer responds with text output, rather than a visual interface built from buttons, icons, and windows you click with a mouse.

Here is an encouraging pattern worth noticing: text-based areas like a terminal are often far more screen-reader-friendly than complex, highly visual parts of an interface. A terminal is, at its core, just a stream of text in and text out. A screen reader reads plain text extremely well, since reading text accurately is the single most fundamental thing it is built to do. This differs from a visually complex panel full of small icons and nonstandard controls, where a screen reader must interpret a far more complicated structure, and where mistakes are more likely.

To open the integrated terminal, use the command palette, the same reliable method from earlier in this lesson: search for the word "terminal," and choose the command to open a new integrated terminal from the results. Once it is open, your screen reader will typically announce that focus has moved into a terminal area. You can then type an ordinary text command, such as one that lists the files in the current folder, and press Enter. The output appears as plain text in the terminal, and you can read it with Say All, or your screen reader's continuous reading command, exactly the same command you already use to read a long document or a long AI response.

One practical note: once your focus is inside the terminal, your screen reader may switch automatically into a mode, sometimes called focus mode, where most keystrokes go directly to the terminal program instead of being intercepted for browsing, since a terminal expects you to type freely. If you need to read output the way you would read regular text, you may need to explicitly switch your screen reader into its browsing or reading mode, or rely on Say All, which works in both modes. Noticing which mode you are in, and switching deliberately, is a skill that gets faster with practice.

Editing .md, .json, and .py Files With a Screen Reader

This section gives you hands-on practice with three file types you are likely to encounter once you start using AI tools for real, employment-relevant work: a readable document, a piece of structured data, and a small automated script. Getting comfortable opening, reading, and editing each one now, inside one consistent editor, is valuable groundwork for anything you build later.

A Markdown file, with the file extension .md, is a plain text file used to write documents, notes, and instructions with simple formatting, such as headings and bullet lists, using ordinary typed characters instead of a visual formatting toolbar. For example, typing a number sign followed by a space before a line of text marks that line as a heading. Markdown files are common for documentation and for README files that explain a piece of software. To open one in VS Code, use the command palette to search for "open file," or use a standard file-opening shortcut, then navigate to the file. Once it is open, your screen reader reads it exactly like reading any other text file: arrow line by line, or use Say All to hear the whole file read aloud. To make a simple edit, move your cursor to the end of the file, type a new line starting with a number sign and a space, followed by a short sentence, and save the file using the standard save shortcut, Ctrl+S on Windows and Linux or Cmd+S on a Mac.

A JSON file, with the file extension .json, short for JavaScript Object Notation, is a plain text file used to store structured data in a format many programs and AI tools can read reliably, such as a list of settings or a small record with named pieces of information. A simple JSON file might contain a name and a short note, written using curly braces, quotation marks, and colons in a specific, consistent pattern. JSON's structure is strict: every quotation mark, comma, colon, and brace matters, and one missing character can make the whole file invalid, worth knowing before you start editing one. When you open a JSON file with a screen reader, you will hear the punctuation read aloud as you arrow through the line, dense at first but easier with practice. To edit one safely, add a new piece of information following the exact pattern already in the file, then save and reopen it to confirm it still reads correctly.

A Python file, with the file extension .py, is a plain text file containing instructions written in Python, a widely used programming language known for being relatively easy to read, even for beginners, because it favors plain, clear commands over dense symbols. A very simple Python file might contain a single line that displays a short message when it is run. Opening and reading a .py file in VS Code with a screen reader works exactly like the other two file types: open it through the command palette or a standard file-opening shortcut, then read it line by line or with Say All. To make a simple edit, add a new line following the same pattern as an existing line, and save the file.

Across all three file types, the underlying screen reader skills are the same: open a file, read it with Say All or line by line, make a small, deliberate edit, and save. What changes between file types is not how you operate your screen reader, but what the file's content and structure mean.

Between an AI assistant built into familiar office software and an AI-aware code editor built for a very different audience, the pattern from this lesson is the same: explore first, use your tool's own search or help feature when you are unsure, and test the accessibility for yourself instead of assuming it based on a company's description or a single lesson. That habit will keep serving you as you continue building practical, job-ready AI skills, tool by tool, well beyond this course.

Key terms from this week

Use this list to review the vocabulary introduced in this lesson before you start the exercises and the test.

Copilot (Microsoft 365)

An AI assistant built directly into Word, Excel, PowerPoint, Outlook, and other Microsoft 365 apps, able to draft, summarize, analyze, and answer questions about the file you currently have open.

Extension

A separate, small piece of software you can install into VS Code to give it a new feature it did not have by default, such as AI coding assistance.

Screen reader mode

A mode in an application like VS Code that changes or turns off certain visual-only features so that what a screen reader announces stays clear and predictable.

Command palette

A searchable list of essentially every command VS Code can perform, opened with Ctrl+Shift+P (or Cmd+Shift+P on a Mac) and searched by typing a keyword.

Terminal

A text-based command-line area where you type text commands and the computer responds with text output, rather than a visual interface built from buttons and icons.

.md (Markdown file)

A plain text file used to write documents and notes with simple formatting, such as headings, using ordinary typed characters.

.json (JSON file)

A plain text file used to store structured data, such as settings or a small record, in a strict, consistent pattern of curly braces, quotation marks, and colons.

.py (Python file)

A plain text file containing instructions written in Python, a widely used, relatively easy-to-read programming language, often used for automation scripts.

Keyboard-only exercises

These exercises use only your keyboard. Screen reader commands are described in general terms below; substitute your own screen reader's equivalent command where needed. The first exercise uses Microsoft Copilot in an Office app; the second and third use VS Code.

Exercise 1: Draft and Revise a Short Report With Copilot

1. Open Word, or another Microsoft 365 app of your choice, and create a new blank document.
2. Open Copilot using whatever method exists in your current version of the app: a toolbar button, a search box, or your screen reader's heading navigation or landmark and region navigation to locate a Copilot pane. If you cannot find it, search the app's own Help for the word "Copilot."
3. In Copilot's message box, type a specific request, such as "draft a three-paragraph report summarizing our team's progress this month, in a professional tone," and submit it.
4. Read the draft using Say All, or your screen reader's continuous reading command.
5. Type a follow-up request to revise it, such as "make it shorter" or "make the tone more casual," and read the revised draft the same way.

Exercise 2: Find the Command Palette and Search for a Setting

1. Open VS Code.
2. Press Ctrl+Shift+P on Windows or Linux, or Cmd+Shift+P on a Mac, to open the command palette.
3. Confirm your screen reader announces an edit field.
4. Type the word "accessibility" and use your screen reader's navigation to arrow through the filtered list of matching commands, reading each one.
5. Choose a command related to accessibility settings and activate it with Enter, then explore the resulting settings area using your screen reader's heading navigation.

Exercise 3: Open the Integrated Terminal and Edit a Markdown File

1. In VS Code, press Ctrl+Shift+P or Cmd+Shift+P to open the command palette, type "terminal," and choose the command that opens a new integrated terminal.
2. Confirm your screen reader announces that focus has moved into a terminal area, then type a simple command that lists the files in the current folder and press Enter.
3. Read the output using Say All, or your screen reader's continuous reading command.
4. Use the command palette again, search "open file," and open or create a file ending in .md.
5. Add a new line to the file starting with a number sign and a space, followed by a short sentence, then save the file with Ctrl+S or Cmd+S.

Portfolio project: My Office Copilot and VS Code Field Notes

This week's portfolio piece is an honest, personal record of testing two very different AI-integrated tools with your own screen reader, continuing the "test it yourself" habit this lesson describes for every tool.

1. Open a word processor or plain text document for your notes.
2. Write a heading at the top: "My Office Copilot and VS Code Field Notes."
3. Choose one Microsoft Office app (Word, Excel, PowerPoint, or Outlook) and test Copilot in it with at least two different requests relevant to real work, such as drafting a report, explaining a formula, outlining a presentation, or drafting an email reply.
4. Write a short, honest paragraph describing what happened: how you opened Copilot, what your screen reader announced, whether the response was easy to read and edit, and anything that felt confusing.
5. Open VS Code and test the command palette and the integrated terminal, using this week's exercises as a starting point. If you have access to an AI extension, try its chat panel as well.
6. Write a second short, honest paragraph describing your VS Code experience: whether the command palette worked as described, how the terminal sounded, and, if you tried an extension, how well it was announced.
7. End with one paragraph rating each tool's accessibility on your own simple scale, such as "worked well," "worked with effort," or "did not work well," with one sentence explaining why for each.
8. Save the file with the name my-office-copilot-and-vscode-field-notes, in your portfolio folder.

Weekly test

Answer key

Each answer below includes a one-sentence explanation drawn from this week's lesson.