GitHub Copilot app for Beginners: How to teach Copilot about your codebase

GitHub published the latest installment of its Copilot app for Beginners series, a walkthrough of four mechanisms for teaching Copilot the conventions, procedures, and external tools a specific codebase relies on. The post, from the GitHub Blog's AI & ML feed, frames the problem plainly: every repository has house rules covering component structure, scripts, and conventions that differ by framework and file type, and Copilot performs better when it can read those rules from the repository itself rather than being told again each session.
The first mechanism is repository custom instructions. A file at .github/copilot-instructions.md carries guidance that applies across the whole repository, such as preferred architecture, naming conventions, and testing or validation expectations. GitHub also supports path-specific instruction files under .github/instructions, which use an applyTo field to declare when the guidance is relevant. When Copilot works on a matching file, it can draw on both the repository-wide instructions and the narrower guidance, so broad rules stay in one place without forcing every file type into the same mold.
Second are agent skills, aimed at procedures rather than standards. A skill is a folder holding instructions and, optionally, scripts and other resources that Copilot loads when relevant. Project-level skills live under .github/skills, each in its own subfolder. GitHub's example is a .github/skills/quality-checks folder containing a SKILL.md file that states when Copilot should use the skill, which scripts run tests and linting, what each script checks, and how to troubleshoot common failures. The description in SKILL.md helps Copilot decide when the skill applies; after an interface update, Copilot can load that skill and follow the project's established testing and linting process instead of guessing at commands.
Third are custom agents, intended for work broader than a single procedure. An accessibility review, for instance, may require inspecting components, templates, styles, and interactions across many files. A repository-level agent profile lives in .github/agents and can define the agent's purpose, instructions, tools, and project context. GitHub's guidance is to reach for a custom agent when a recurring type of work benefits from a dedicated role or perspective, particularly when the task spans files and draws on multiple tools or sources of context.
Fourth is the Model Context Protocol, which connects Copilot to external tools, data sources, and services beyond the repository. GitHub gives two examples: a documentation server that supplies framework guidance, and Playwright, which lets Copilot open and interact with an application in a browser. Servers can be browsed in the Copilot app or added as custom entries. Once Playwright is configured, a developer can ask Copilot to use the Playwright MCP server to test functionality manually, and Copilot will open the app in a browser and interact with it, verifying that the updated interface behaves as expected rather than only that automated checks pass.
My reading is that these four layers map to different scopes of context. Instructions are declarative rules attached to paths; skills are procedural recipes loaded on demand; agents are role definitions that bundle instructions, tools, and context for larger jobs; MCP servers are capabilities that reach outside the repository. In practice the boundaries are soft. A skill can call scripts, an agent can load skills, and an MCP server can supply data that instructions assume is available, so teams will need some discipline about where a given piece of knowledge belongs to avoid duplication and drift.
The post also suggests combining the mechanisms and offers four questions to decide where to start: which project convention do you keep explaining, which multi-step procedure do you repeat, which complex task could benefit from a dedicated agent, and which outside tool or source does Copilot need. GitHub points to Awesome Copilot, a community collection of ready-made instructions, skills, and agents, as a starting point, advising readers to find one that addresses a repeated workflow, review its contents, and adapt it to their own tools and standards. Its suggested first step is deliberately small: pick one convention you keep explaining, add it to .github/copilot-instructions.md, and see how Copilot applies it on the next task.
The framing throughout is that context is a repository artifact, not a prompt. That is a meaningful shift for teams already maintaining style guides, contributor docs, and CI scripts, since these files live in version control and travel with the code. A likely trade-off is maintenance overhead: instruction and skill files that drift out of sync with the actual build scripts can mislead Copilot as confidently as they guide it, and because they are plain text in the repo, they will show up in code review like any other change. MCP servers add a separate surface, since each server is a package that the team must configure, trust, and keep current. The post does not go into security or permission details for MCP servers, so teams adopting them should expect to work that out themselves.
Why it matters: developers using Copilot in team repositories can now encode conventions and repeatable procedures as versioned files rather than re-explaining them in prompts, which should reduce repetitive setup and make AI-assisted edits more consistent with existing patterns. Product teams evaluating AI coding tools may find that the quality of results depends less on the model and more on how much repository context has been captured. The main work shifts from prompting to curating and maintaining that context, and from reviewing individual edits to reviewing the instructions that shape them.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
Learn how to add custom instructions and skills to your repository, use custom agents, and connect MCP servers like Playwright. The post GitHub Copilot app for Beginners: How to teach Copilot about your codebase appeared first on The GitHub Blog .