GitHub Copilot: Zero to Hero – The Complete 2026 Field Guide
A complete field guide to GitHub Copilot in 2026. Covers every primitive – copilot-instructions.md, AGENTS.md, extensions, MCP, coding agent, hooks, permissions, context management – then advances into Copilot CLI, /fleet multi-agent workflows, model configuration, scheduling, and security best practices. Language and framework agnostic.
Prabhat Kashyap
GitHub Copilot started as the world’s most popular autocomplete tool. In 2026 it is a multi-surface agentic system: it lives in your IDE, your terminal, your CI pipeline, and GitHub itself. You can assign it a GitHub Issue and walk away. It reads the codebase, writes the code, opens a pull request, and waits for your review.
Most developers are still using 10% of what Copilot can do. This guide covers the rest: from the IDE integration and three CLI interaction modes, through instruction files that make Copilot project-aware, path-specific rules, custom agents, Skills, MCP integrations, CLI permissions, and the security model you need before running autonomous agents in production.
1. Introduction: from autocomplete to agent
When GitHub Copilot launched, the mental model was simple: AI helps you type faster. That model is now obsolete. In 2026, Copilot operates at the task level. In agent mode inside VS Code it reads your workspace, proposes a multi-file edit plan, runs your tests, self-heals compilation errors, and iterates until done. Via the coding agent on GitHub.com you assign it an Issue and it opens a draft PR. Via Copilot CLI it runs autonomously in your terminal with full command-execution rights.
The shift is from line-level suggestion to task-level delegation. For teams already on GitHub, the integrations are native: Issues, PRs, Actions, and Discussions are first-class surfaces, not bolt-ons.
GitHub reports that developers using Copilot coding agent merge 37% more pull requests per day and spend 55% less time on routine implementation. The gains compound with instruction quality: copilot-instructions.md and well-written AGENTS.md files determine how well Copilot understands your specific project.
Installation
# VS Code - install from Extensions panel (search "GitHub Copilot")# or from terminal:code--install-extensionGitHub.copilotcode--install-extensionGitHub.copilot-chat# Copilot CLI - terminal-native agentic modenpminstall-g@github/copilotcopilotauthlogin# GitHub CLI with Copilot extensionghextensioninstallgithub/gh-copilotghcopilot--help
Bash
Copilot CLI works with GitHub Copilot Free, available to all personal GitHub accounts. No paid subscription is required to follow along with the examples in this guide.
2. Ways to use GitHub Copilot
GitHub Copilot is a family of tools, not a single product. Each surface has a distinct role and sweet spot. Understanding all of them – and knowing which to reach for – is the first skill to develop.
Surface
Where it runs
Best for
Async?
Inline autocomplete
IDE
Fast routine implementation
No
Copilot Chat
IDE / GitHub.com
Questions, explanations, targeted code
No
Edit mode
IDE
Coordinated multi-file changes
No
Agent mode
IDE + terminal
Complex tasks with tool use, self-healing
No (live)
Coding Agent
GitHub Actions cloud
Issue-to-PR delegation
Yes
Copilot CLI
Terminal
Terminal-native work, automation, /fleet
No (live)
3. The three CLI interaction modes
The official GitHub Copilot CLI for Beginners course uses a restaurant analogy to explain the three modes. Interactive mode is a back-and-forth conversation with a waiter. Plan mode is mapping your route before you drive. One-shot mode is the drive-through: one request, one output, done.
Interactive mode
# Start an interactive sessioncopilot# Reference files with @ inside the session> Review @src/service/PaymentService.ts for correctness> Now fix the issues you found> Run the tests and show me what fails
Plaintext
Plan mode
# Toggle plan mode with Shift+Tab inside an interactive sessionShift+Tab # Enter plan mode# Copilot presents a blueprint before acting:Plan: 1. Read src/service/PaymentService.ts for current structure 2. Create src/repositories/PaymentRepository.ts with interface 3. Refactor PaymentService to inject the repository 4. Update 3 call sites: auth.ts, admin.ts, checkout.ts 5. Run tests to verify no regressions Press Enter to proceed, or describe a change to the plan.# Shift+Tab again switches to autopilot (executes without step approval)
Plaintext
One-shot mode
# Execute and exitcopilot-p"review @src/service/PaymentService.ts for correctness"# Pipe test failures for analysisnpmtest2>&1|copilot-p"diagnose these test failures"# Pipe test failures for fixesnpmtest2>&1|copilot-p"fix all failing tests"--allow-tool'shell(npm)'# Pipe git diff for automated reviewgitdiffHEAD~1|copilot-p"review this diff for bugs and security issues"# Generate a PR descriptiongitdiffmain...HEAD|copilot-p"write a clear PR description"# JSON output for scriptscopilot-p"list all TODO comments in src/"--output-formatjson
Bash
Mode selection guide
Situation
Mode to reach for
Exploring a codebase or asking questions
Interactive
Multi-file refactor with many unknowns
Plan, then autopilot
Routine code review or test generation
One-shot (-p flag)
CI/CD pipeline automation
One-shot (-p flag)
Debugging a complex issue
Interactive with @ references
Autonomous async task from a GitHub Issue
Coding Agent (cloud)
4. Context with @ references and session management
Chapter 2 of the beginners course covers how to point Copilot at your code using @ references, and how to carry context across sessions so follow-up questions build on what came before.
@ references in Copilot CLI
# Reference a single file> Review @src/service/PaymentService.ts for anti-patterns# Reference a whole directory> Analyse @src/domain/ and explain the data model# Reference multiple files in one prompt> Compare @src/service/TransferService.ts and @src/service/PaymentService.ts> and suggest which patterns from Payment should be applied to Transfer# Reference a config file> Given @CLAUDE.md, does @src/api/routes.ts follow our architecture rules?
Plaintext
Context variables in VS Code Chat
# VS Code Copilot Chat context variables@workspace # Indexed workspace representation@terminal # Current terminal output (test failures, build errors)#file:path/to/file # Full content of a specific file#selection # Currently selected text in the editor#codebase # Semantic search across the entire codebase#sym:SymbolName # Definition and all usages of a symbol
Plaintext
Session management
# Resume the most recent sessioncopilot--continue# Pick from a list of previous sessionscopilot--resume# Context management commands inside an interactive session/clear# Clear history, start fresh (system context stays)/compact# Compress history and continue (no context lost)/status# Show current token usage# Session persistence (on by default)copilotconfigsetsession.persistfalse# Disable cross-session memory
Bash
Auto-compaction fires at 95% of the token limit. Copilot summarises the conversation history and continues without interrupting your workflow. You can also trigger it manually with /compact.
5. Understanding the project structure
Below is the anatomy of a GitHub Copilot-wired project. Every file has a precise role. Understanding which primitive does what is the foundation for everything else in this guide.
Key file roles at a glance
File
When loaded
Scope
Claude Code equivalent
.github/copilot-instructions.md
Every session
All files
CLAUDE.md
CLAUDE.md
Every session (VS Code)
All files
CLAUDE.md
.github/instructions/*.instructions.md
When applyTo matches
Matched files only
Lazy-loaded skills
.github/prompts/*.prompt.md
On demand (/name)
Invoked context
Skills (SKILL.md)
.github/agents/*.agent.md
On demand (@name)
Agent session
Subagents
AGENTS.md
Coding agent tasks
Cloud agent only
CLAUDE.md for agents
6. GitHub Copilot workflow
The daily delegation loop
Inline autocomplete for speed, Chat for reasoning. Tab-complete routine boilerplate. Switch to Chat for anything requiring multi-file reasoning or architectural judgment.
Point Copilot at your code with @ references. Use @src/service/PaymentService.ts rather than relying on workspace indexing alone. Explicit context is always more reliable than implicit.
Use a prompt file for repeatable tasks./review runs your review.prompt.md playbook. /review-pr 42 runs the PR review with the PR number. No re-typing instructions every session.
Invoke an agent for specialist work.@unit-test src/service/PaymentService.ts delegates test generation to your unit-test agent, which already knows your test framework conventions.
Delegate async work to the coding agent. Write a well-specified GitHub Issue, assign Copilot, review the draft PR when it is ready.
The pipe and review workflow
# Pipe test failures to Copilot for fixes (language-agnostic)npmtest2>&1|copilot-p"fix all failing tests"# or: pytest 2>&1 | copilot -p "fix all failing tests"# or: go test ./... 2>&1 | copilot -p "fix all failing tests"# Review staged diff before committinggitdiff--staged|copilot-p"review for correctness and security issues"# Generate PR description from diffgitdiffmain...HEAD|copilot-p"write a clear PR description"# Update changeloggitlogv1.0.0..HEAD--oneline|copilot-p"write a CHANGELOG entry"
Bash
7. Best practices
Write specific prompts
Weak prompt
Strong prompt
“Improve the code”
“Refactor PaymentService to use the repository pattern. Keep the public interface identical. No new dependencies.”
“Write tests”
“Write unit tests for PaymentValidator covering: null input, negative amounts, expired cards, and currency mismatch. Use [your test framework].”
“Fix the bug”
“Fix the race condition in OrderProcessor.processQueue that causes duplicate charges under concurrent load”
Instruction file hygiene
Keep copilot-instructions.md under 1,000 lines. GitHub guidance: files over this length start to degrade Copilot’s ability to follow all rules consistently.
Put language rules in path-specific files, not the main file. TypeScript-specific patterns belong in lang.instructions.md with applyTo: "**/*.ts", not in the global file where they consume context for non-TypeScript tasks.
Include reasoning behind rules. “Use parameterised queries because string concatenation causes SQL injection” outperforms “use parameterised queries”. The AI responds better to the why.
Show preferred and avoided patterns with code examples. Abstract rules are less effective than concrete before/after examples.
Commit everything. copilot-instructions.md, all .instructions.md files, prompts, and agent definitions are team infrastructure. Version them, review changes in PRs, update them when conventions evolve.
.github/copilot-instructions.md is loaded into every Copilot chat, edit, and agent session. It is your team’s shared context, the one file that shapes every interaction. A well-written copilot-instructions.md turns Copilot from a capable generalist into a specialist who knows your project as well as a senior engineer would after a month of onboarding.
# your-project - Copilot Instructions## StackLanguage: [Language + version]Framework: [Primary framework + version]Database: [DB + query layer]Test runner:[Framework]Build: [Build tool]Lint/format:[Tool + config location]## Architecture - ALWAYS respect these boundaries[2-3 sentences describing layers and their rules.E.g.: "Three-layer: routes -> services -> repositories.All business logic lives in services/. No DB queries outside repositories/."]## Conventions - ALWAYS- [Your pattern, e.g. "use async/await, never raw Promises"]- [Naming rule, e.g. "camelCase for variables, PascalCase for classes"]- [Error handling, e.g. "use Result types for expected errors, throw for unexpected"]## Conventions - NEVER- [Anti-pattern #1, e.g. "never use any in TypeScript"]- [Anti-pattern #2, e.g. "never put business logic in route handlers"]- [Anti-pattern #3, e.g. "never commit console.log statements"]## Build and Run- build: [command]- test: [command]- lint: [command]- format: [command]## Security[Key rules for your domain, e.g. "never log PII or payment card data"]
Plaintext
Instruction priority stacking
Copilot combines instructions from multiple sources. Personal instructions (your individual VS Code settings) take highest priority, then repository instructions (.github/), then organisation instructions (enterprise-wide). When both copilot-instructions.md and a matching .instructions.md path file apply, both are merged and sent to Copilot.
9. Path-specific instructions: the applyTo system
The applyTo system lets you write instruction files that only load when Copilot is working on files matching a glob pattern. Your base context stays lean; deep specialisation loads exactly where needed.
---applyTo:"**/*.ts"---# TypeScript Coding Standards## Type system-Prefer specific types over 'any'. Use 'unknown' when the type is genuinely unknown.-Use strict null checks. Handle null and undefined explicitly.-Use type aliases for complex types, interfaces for object shapes.## Error handling-Use Result<T, E> or a typed Either pattern for expected errors-Never silently swallow errors with empty catch blocks-Log the error before re-throwing or transforming it## Testing-Every exported function needs at least one happy-path and one error-path test-Use factories for test data, not inline object literals-Mock at the boundary:mock HTTP clients and DB adapters, not internal services
YAML
---applyTo:"tests/**"excludeAgent:"code-review"---# Testing Standards# (excluded from code-review agent which has its own checklist)## Test structure-Arrange-Act-Assert:keep sections clearly separated-One assertion concept per test:do not assert five things in one it() block-Test names describe behaviour, not implementation:"returns error when amount is negative"not "test_paymentValidator"## Test data-Use factory functions for shared test objects-Do not share mutable state between tests-Clean up side effects in afterEach/teardown
YAML
applyTo glob patterns
Pattern
What it matches
**/*.ts
All TypeScript files anywhere in the project
src/api/**/*.ts
Only files in the API layer
**/*.{ts,tsx}
All TypeScript and TSX files
tests/**/*
All test files
**
All files (equivalent to always-on)
10. AGENTS.md and prompt files
AGENTS.md: for the coding agent
AGENTS.md is read by the Copilot coding agent when assigned a GitHub Issue. It runs in a sandboxed cloud environment with no memory of past sessions. Make it operational: the agent needs to know exactly how to set up, build, and test your project from a clean state.
# AGENTS.md## Environment setupTheagentrunsinacleanUbuntuenvironment.Beforeanytask:1.Run: [your installcommand,e.g.npminstall]2.Run: [your buildcommand]andverifyzeroerrors## Build and test commands-build: [command]-test: [command]-lint: [command]-format: [command]## Architecture constraintsSee.github/copilot-instructions.mdforfulllayerrules.Critical:NEVERplacebusinesslogicoutsideof [your serviceslayer].## Security constraints - unconditional1.NEVERmodify.github/workflows/files2.NEVERchangeauthenticationorsessionhandlingcode3.NEVERlograwuserdata,passwords,orpaymentinformation4.NEVERadddependencieswithoutnotingtheminthePRdescription5.Ifarequiredsecretismissing,STOPandexplaininaPRcomment## Definition of doneAtaskiscompletewhen:1.Alltestspass2.Lintpasseswithzerowarnings3.AdraftPRisopenreferencingtheissuenumber
Custom agents are named Copilot instances with their own model, tools, MCP servers, and instruction set. From the beginners course: agents are like hiring specialists. You hire a plumber for plumbing and an electrician for electrical work. Rather than a single generalist AI, you create focused agents that are excellent at one specific thing.
Team members share agents through the .github/agents/ directory committed to version control. Every developer gets the same set of specialists without any individual setup.
12. Skills: auto-triggered task instructions
Skills are one of the most distinctive features of the Copilot CLI, and Chapter 5 of the beginners course dedicates a full chapter to them. If agents are specialists you hire, skills are attachments for a power drill: you pick the right one for the job and it changes what the tool can do. Unlike agents (invoked by name with @agent-name), skills auto-trigger based on your prompt without you specifying them explicitly.
Where skills live
# Project-level skills (committed, shared across team).github/skills/skill-name/SKILL.md# Personal skills (available across all projects on your machine)~/.config/copilot/skills/skill-name/SKILL.md# Install from the Awesome Copilot marketplacecopilotplugininstall<skill-name>@awesome-copilot
Bash
Anatomy of a skill file
# .github/skills/code-review/SKILL.md---name: code-reviewdescription: | Performs a comprehensive code review. Auto-invoke when the user asks to review, check, or audit any code or file.triggers: - "review" - "check" - "audit" - "code quality"version: 1.0---## Code review checklist### Correctness- [ ] Logic matches the stated intent- [ ] Edge cases are handled (null, undefined, empty collections)- [ ] No off-by-one errors or boundary issues### Security- [ ] No hardcoded credentials, tokens, or secrets- [ ] All external input is validated before use- [ ] No injection risks (SQL, command, path traversal)### Code quality- [ ] Functions are focused on a single responsibility- [ ] Names are clear and descriptive- [ ] Error handling is consistent with the project conventions in copilot-instructions.md## Output formatFor each issue: file + line, severity, description, concrete fix with code example.Summary: APPROVE or REQUEST CHANGES.
Markdown
More skill examples
# .github/skills/commit-message/SKILL.md---name: commit-messagedescription: | Generates a conventional commit message from staged changes. Auto-invoke when the user asks for a commit message or wants to commit.triggers: - "commit message" - "git commit" - "conventional commit"---Generate a conventional commit message for the staged changes.Format: type(scope): short descriptionTypes: feat, fix, docs, style, refactor, test, choreScope: the component affected (service, db, api, config)Rules:- Subject line max 72 characters- Use imperative mood ("add" not "added")- Reference issue number if mentioned in the prompt- If breaking change, add BREAKING CHANGE: in the footer
Markdown
Skills vs agents vs prompt files
Tool
Invocation
Best for
Skill
Auto-triggers from natural language
Repeatable workflows that should activate without thinking about them
Prompt file
Explicit: /review
Structured task playbooks you invoke intentionally
Agent
Explicit: @reviewer
Specialist work needing a dedicated model, tools, or MCP access
13. Permissions: trusted directories, tools, paths, and URLs
# Allow all tools without individual promptscopilot-p"run tests and fix failures"--allow-all-tools# Allow specific toolscopilot--allow-tool'shell'# any shell commandcopilot--allow-tool'write'# file writes without approvalcopilot--allow-tool'github-mcp'# all tools from GitHub MCP server# Deny specific tools (takes precedence over allow)copilot--deny-tool'shell(rm)'# block all rm commandscopilot--deny-tool'shell(git push)'# block git pushcopilot--deny-tool'My-Server(tool)'# block a specific MCP tool# Allow everything except dangerous shell ops (safe CI pattern)copilot--allow-all-tools\--deny-tool'shell(rm)'\--deny-tool'shell(git push)'# Restrict to an exact set of tools (all others blocked)copilot--available-tools'shell(npm),shell(git),write'# Allow all tools, paths, and URLs (sandboxed environments only)copilot--allow-all# alias:copilot--yolo
Bash
Tool specifier reference
Specifier
What it controls
shell
Any shell command
shell(npm)
Only the npm command
shell(git push)
Only git push
write
All non-shell file modification tools
SERVER_NAME
All tools from a named MCP server
SERVER_NAME(tool)
A specific tool from a named MCP server
URL permissions
# Pre-approve specific domainscopilot --allow-url github.comcopilot --allow-url docs.yourtech.io# Deny specific domainscopilot --deny-url pastebin.com# Persistent URL config in ~/.copilot/config.json{"allowed_urls": ["github.com", "docs.yourtech.io"],"denied_urls": ["pastebin.com", "transfer.sh"]}# Interactive session commands/allow-all # Enable all tools, paths, and URLs/yolo # Alias for /allow-all
JSON
14. Copilot Coding Agent
The coding agent is Copilot’s most powerful async mode. Assign it a GitHub Issue; it runs in a sandboxed GitHub Actions environment, reads your codebase and AGENTS.md, and opens a draft PR when done. No terminal session required from you.
Triggering the coding agent
# Method 1: Assign Copilot to a GitHub Issue# Open the issue > Assignees > select "Copilot"# Method 2: Copilot Chat on GitHub.com# "@github create a PR for issue #47"# Method 3: Copilot CLIghcopilotagentrun--issue47# Method 4: GitHub Actions workflow triggerghworkflowruncopilot-fix.yml-fissue_number=47
Bash
Writing effective Issues for the coding agent
# Weak issue - agent will guess and likely be wrongTitle: Add caching# Strong issue - agent has everything it needsTitle: Add response caching to GET /api/products endpoint## ContextGET /api/products is called ~10k times/minute. The underlying DB querytakes 200ms and results change at most once per hour.## Implementation- Use the existing cache client at src/cache/RedisClient.ts- Cache key: products:all- TTL: 3600 seconds (1 hour)- Invalidate on any write to the products table- Layer: db/ for cache access, service/ for invalidation## Files to touch- src/db/ProductRepository.ts (add cache read/write)- src/service/ProductService.ts (add cache invalidation on write)## Done when- All tests pass- Cache hit returns in under 5ms (verify in integration test)- Draft PR open referencing this issue number
Markdown
Coding agent security boundaries
Branch protections are fully respected. The agent cannot bypass required checks.
CI/CD requires human approval to run on agent-created PRs.
Secret scanning is active. Push protection blocks secrets from agent commits.
The agent creates draft PRs by default and never merges autonomously.
Internet access is controlled. Only pre-approved domains are reachable.
15. Hooks and GitHub Actions
GitHub Actions: automated PR review
name:CopilotPRReviewon:pull_request:types: [opened, synchronize]jobs:copilot-review:runs-on:ubuntu-latestpermissions:contents:readpull-requests:writesteps:-uses:actions/checkout@v4with:fetch-depth:0-name:ReviewwithCopilotenv:GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}run:|gitdifforigin/${{ github.base_ref }}...HEAD|\copilot-p\"Review this diff. Flag bugs, security issues, and violations of our conventions from .github/copilot-instructions.md. Be specific: file + line + fix for each issue."\--allow-tool'shell'>review.txt-name:Postreviewuses:actions/github-script@v7with:script:|constr=require('fs').readFileSync('review.txt','utf8');github.rest.issues.createComment({issue_number:context.issue.number,owner:context.repo.owner,repo:context.repo.repo,body:`## Copilot Code Review\n\n${r}` });
Bash
Nightly security audit
name:NightlySecurityAuditon:schedule:-cron:'0 2 * * *'jobs:audit:runs-on:ubuntu-latestpermissions:contents:readissues:writesteps:-uses:actions/checkout@v4-name:Rundependencyauditrun:npmaudit--json>audit.json||true-name:AnalysewithCopilotenv:GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}run:|cataudit.json|\copilot-p\"Analyse these dependency vulnerabilities. For each Critical/High: package, severity, CVE, and recommended fix action."\--allow-tool'shell'>analysis.txt-name:Openissueifvulnerabilitiesfounduses:actions/github-script@v7with:script:|consta=require('fs').readFileSync('analysis.txt','utf8');if (a.includes('Critical') ||a.includes('High')) {github.rest.issues.create({owner:context.repo.owner,repo:context.repo.repo,title:`Security audit ${newDate().toISOString().split('T')[0]}`,body:a,labels: ['security', 'automated'] }); }
Bash
16. Managing context
Start a new chat for each distinct task. Long multi-topic sessions degrade context quality. Use /clear for a fresh session or start a new one.
Use path-specific instructions to keep base context lean. Language-specific rules in lang.instructions.md with applyTo only load when editing matching files, not when generating a CHANGELOG or updating a config file.
Pipe, do not paste.npm test 2>&1 | copilot -p "diagnose" uses a fresh stateless context rather than polluting your current session with hundreds of lines of build output.
Use –continue and –resume. Close the terminal and come back later with copilot --continue to resume with full conversation history intact.
17. Advanced GitHub Copilot
Connecting tools with MCP
From the beginners course: MCP servers are like browser extensions. Just as you install an extension to give your browser new capabilities, MCP servers give Copilot new capabilities by connecting it to external services. GitHub Copilot CLI includes a native GitHub MCP server that connects to issues, branches, and pull requests without any additional setup.
# Switch models in Copilot CLI/model# Open model picker/modelgpt-4.1# Fast implementation tasks/modelclaude-opus-4-5# Complex refactors, architecture decisions/modelo3# Deep debugging, concurrency issues# Plan mode: review intent before executionShift+Tab# Enter plan modeShift+Tab# Again to switch to autopilot mode
Bash
Scaling with /fleet and agent teams
# /fleet: parallel subagents on the same task/fleet"review this module for correctness, performance, and security"# Spawns 3 agents simultaneously:# Agent 1: correctness review# Agent 2: performance analysis# Agent 3: security audit# Results synthesised into one consolidated report# Fleet with different models for multiple perspectives/fleet--modelsgpt-4.1,claude-opus-4-5\"design the caching layer for this feature - I want two perspectives"
Bash
Security best practices
Always pair --allow-all-tools with explicit --deny-tool rules for dangerous operations (shell(rm), shell(git push), deploy commands).
Run headless Copilot CLI in a Docker container or CI runner, never directly on a production server.
Set hard timeouts on all automated Copilot invocations: timeout 300 copilot --allow-all-tools -p "..."
Never commit ~/.copilot/config.json. It may contain trusted path lists and personal tokens.
Use GitHub Secrets (not repository variables) for credentials used by the coding agent. Prefix MCP-bound secrets with COPILOT_MCP_.
Add all sensitive file patterns to content exclusions before enabling any agent mode.
Parallel workstreams, nightly audits, team automation
The teams winning with GitHub Copilot are not the ones with the most plugins installed. They are the ones who invested in their instruction files, wrote clear Issues, used the applyTo system to keep context lean and precise, and built skills that auto-trigger so good practices happen without anyone having to remember to ask.
Resources
Official GitHub Copilot CLI course
GitHub Copilot CLI for Beginners – Free, open-source 8-chapter course by GitHub (March 2026). Works with a project throughout all chapters. Open in Codespaces for a fully configured environment.
Senior Technical Architect
@ HCL Tech · working with Leonteq Security AG
10+ years building distributed systems and fintech platforms.
I write about the things I actually debug at work — the messy,
non-obvious parts that don't make it into official docs.