Forem: Louis Liu

Building a Mini Basketball Game as a VS Code Extension

Louis Liu — Sat, 28 Feb 2026 08:58:54 +0000

I've always wanted to build my own game. Recently, I started learning game development. My first experimental project is a VS Code extension called Swipe Hoop.

It's a basketball mini-game you can play inside VS Code. I wanted to call it "Swipe Basketball" but due to VS Code Marketplace review policies, I couldn't use words like "basketball" or "game" in the extension's name.

It’s a small experiment, but it was surprisingly fun to build.

You can install the extension through Marketplace or just search Swipe Hoop in VS Code. Hope you enjoy the game!

Gameplay

Stop Copy-Pasting to ChatGPT — Meet Snap Mind

Louis Liu — Sat, 14 Feb 2026 08:34:51 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built Snap Mind, an AI-powered desktop assistant that brings large language models directly into your daily workflow — without context switching.

The core idea is simple but powerful:

👉 Select any text

👉 Press a hotkey

👉 Instantly get AI help

Instead of opening ChatGPT or switching tabs, Snap Mind lets you translate, rewrite, summarize, or explain text right where you work. The goal is to make AI feel native to the operating system — fast, invisible, and always within reach.

Key Features

⚡ Blazing Fast — trigger AI with a single keystroke
🧠 Works Anywhere — usable inside any application
🎯 Custom Prompts — tailor AI actions to your workflow
✍️ Multi-purpose — translation, summarization, rewriting, explanations, and more
🔄 Zero context switching — stay in your flow state

Why I Built This

While LLMs are powerful, the friction of opening web apps and copy-pasting text breaks focus. I wanted AI to feel like a native superpower — something that responds instantly to intent.

Snap Mind is my attempt to make AI interaction:

faster
more contextual
and more ergonomic for everyday work

Demo

🔗 GitHub Repo: https://github.com/Snap-Mind/snap-mind
🌐 Website: https://snap-mind.github.io/

Example Use Cases

Translate selected text instantly
Rewrite emails to sound more professional
Summarize long articles
Explain code snippets in place
Generate quick replies without leaving your editor

My Experience with GitHub Copilot CLI

GitHub Copilot CLI significantly accelerated my development workflow while building Snap Mind.

How I Used It

I used Copilot CLI to:

scaffold boilerplate code
generate shell commands
speed up debugging workflows
explore unfamiliar APIs quickly
iterate on prompt templates

One particularly helpful workflow was using Copilot CLI to quickly generate and refine command-line interactions during early prototyping. It reduced the cognitive overhead of context switching and let me stay focused on product design.

Impact on My Development Experience

What worked well:

🚀 Faster iteration loops
🧩 Reduced time spent on repetitive tasks
🔍 Helpful for exploring unfamiliar code patterns
💡 Great for quick command suggestions

What I learned:

Copilot CLI shines most when you:

give clear, focused prompts
use it interactively during development
treat it as a collaborator, not an autopilot

Overall, it helped me move from idea → prototype → usable tool much faster.

My New Year Portfolio Challenge!

Louis Liu — Fri, 23 Jan 2026 10:52:20 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

I'm Louis, a full-stack web developer with a strong focus on web technologies.

Portfolio

Or access it in your browser: https://dev-valley-315140115302.us-west1.run.app/

How I Built It

I have always wanted to create a personal homepage that reflects my unique style. As a big fan of video games, I want to have gaming elements in my page. Based on this idea, I used Google AI Studio to bring this personal homepage to life.

What I'm Most Proud Of

98% of the code was written through vibe coding. I'm very pleased that I successfully implemented map switching and interactions between characters and objects. Furthermore, I added a mini-game (here's a hint: it's a fishing game). Although the art style isn't perfect and there is a lack of instructions, I think I've done a good enough job.

What Really Happens When an LLM Chooses the Next Token🤯

Louis Liu — Mon, 12 Jan 2026 03:16:54 +0000

LLM outputs sometimes feel stable. Sometimes they suddenly become random.

Often, the only thing that changed is a parameter.

So what actually happens at the moment an LLM decides which token comes next?

The short answer is simple:

it samples one token from a probability distribution.

Let’s break that moment down with visuals.

The Core Idea

Given a prompt, the model predicts a probability distribution over possible next tokens.

For example:

Twinkle twinkle little

At this point, the model assigns a probability to each candidate token.

You can imagine them laid out on a 0–100 scale:

Higher probability → larger segment
Lower probability → smaller segment

Sampling: What Actually Happens

Next comes sampling.

A practical way to think about it:

Generate a random number

See which segment it falls into

Output the corresponding token

Since “star” has the largest segment, it’s the most likely result:

Twinkle twinkle little star

Temperature, Top-p, and Top-k

only affect this sampling step.

From here on:

Temperature = 1
Top-p = 1
Top-k = 10

We’ll change one parameter at a time.

Temperature

Temperature does one thing:

it stretches or flattens probability differences.

Lower temperature → strong preferences → stable output
Higher temperature → flatter distribution → more randomness

In this example:

The gap between “star” and “car” is 19.6
With Temperature = 0.5, the gap grows to 36.1

With Temperature = 1.68, lower-probability tokens become more competitive:

Key point:

Temperature doesn’t remove tokens.

It only changes how strongly the model prefers one over another.

Top-p (Nucleus Sampling)

Top-p controls how much probability mass is kept.

The process is straightforward:

Start from the highest-probability token
Keep adding tokens until cumulative probability ≥ Top-p
Drop the rest

With Top-p = 0.6, only tokens covering 60% of total probability remain.

The remaining tokens are then renormalized:

This means:

The number of tokens is dynamic
More peaked distributions keep fewer tokens

Top-k

Top-k is simpler.

Keep only the top K tokens.

Top-k = 1 → always pick the most likely token
Top-k = 5 → sample from the top 5

Everything else is ignored.

In one line:

Top-k limits quantity
Top-p limits probability mass

Demo

All visuals in this article come from:

👉 LLM Sampling Visualizer

If sampling parameters feel abstract,

five minutes with this tool builds intuition faster than reading more text.

References

Git Deep Dive: Mastering rerere

Louis Liu — Wed, 12 Nov 2025 18:00:00 +0000

No, It's Not a Typo: Let's Talk About git rerere (Reuse Recorded Resolution)

git rerere helps Git remember how you resolved a conflict previously, and automatically reuses that resolution when the same conflict occurs again. This can be a huge time-saver with recurring merge conflicts.

How to enabled it

Globally:

git config --global rerere.enabled true

Per project:

git config rerere.enabled true

Check status:

git config --get rerere.enabled

Example

I'm updating hello.txt on main and feature/earth branch.

Hello!

On main branch:

Hello World!

On feature/earth branch:

Hello Earth!

Now, if we try to merge feature/earth into main, we’ll get a conflict:

git checkout main
git merge feature/earth

Conflict:

<<<<<<< HEAD
Hello World!
=======
Hello Earth!
>>>>>>> feature/earth

We edit the file to:

Hello Universe!

Then stage and commit:

git add hello.txt
git commit

Git will record the resolution:

Recorded resolution for 'hello.txt'.
[main 7fd7eda] Merge branch 'feature/earth'

Next time Git encounters the same conflict, it will automatically reuse the previous resolution:

git merge feature/earth

You got:

Auto-merging hello.txt
CONFLICT (content): Merge conflict in hello.txt
Resolved 'hello.txt' using previous resolution.
Automatic merge failed; fix conflicts and then commit the result.

Useful commands

# Manually trigger rerere
git rerere

# Forget a recored resolution
git rerere forget <file>

# Check the rerere cache
ls .git/rr-cache/
cat .git/rr-cache/<conflict-id>/preimage

If you don’t want Git to auto-resolve using rerere, you can reset the file:

git checkout --conflict=merge <file>

Advanced

When Git detects a conflict during a merge or rebase, it generates a hash key based on the conflicting content — this becomes the conflict-id.

Git then stores:

The preimage (conflicted content)
The postimage (your resolved version)

These are saved under .git/rr-cache/.

File Structure:

.git/
└── rr-cache/
    ├── <conflict-id>/
    │   ├── preimage      # The file before conflict resolution
    │   ├── postimage     # The file after conflict resolution
    │   └── thisimage     # Temporary file used during auto-resolution

Important Notes

The conflict-id is not a Git object, even though it looks like one.
It’s stored locally only — it won’t be pushed to the remote.
If you delete .git/rr-cache, the resolution is gone forever.

Summary

git rerere is a powerful but often overlooked tools. It can save you a lot of time when dealing with recurring merge conflicts.

🧠 Bringing AI to One Keystroke

Louis Liu — Tue, 21 Oct 2025 00:47:43 +0000

This is a submission for the 2025 Hacktoberfest Writing Challenge: Maintainer Spotlight

AI is powerful — but using it still feels… awkward.
Every time I want AI to help me rewrite a sentence, summarize a paragraph, or translate a message, I have to switch apps, paste text, and then jump back into my workflow. It breaks focus.

I live inside Slack, Notion, VS Code, and a dozen other tools every day. I wanted AI to feel invisible — something that’s just there, one keystroke away.

That’s how SnapMind was born.

🧠 What Is SnapMind?

SnapMind is a desktop AI assistant that brings LLMs directly into your daily workflow.

Select any text, hit a hotkey, and instantly:

✍️ Rewrite or polish your content
🌍 Translate text on the fly
📑 Summarize long paragraphs
💡 Explain code or concepts — without leaving your current app

It’s like having ChatGPT, DeepL, and Grammarly in one lightweight popup — always ready, never intrusive.

⚡️ What makes SnapMind Special

SnapMind isn’t just another AI app — it’s a workflow enhancer.
It’s built around three core principles:

Speed: AI should be accessible in a single keystroke.
Seamlessness: Stay in flow — no context switching.
Customization: Save and trigger your favorite prompts instantly.

❤️ Why I Love Maintaining SnapMind

I really appreciate the convenience that AI brings, but most AI applications haven't truly integrated into my work. I still need to frequently switch between different products to achieve my goals. I hope there can be software that truly integrates into my daily work, acting like an invisible partner to help me complete tasks when I need it. This is also the reason SnapMind was created.

I’m deeply grateful to everyone who’s starred the repo. I'm hoping there are more people who will open issues or share feedback. Together, we’re building the kind of AI tool we actually want to use.

🌍 Join Me

If you believe AI should be simple, fast, and seamlessly integrated into your workflow — join me!

⭐️ Star SnapMind on GitHub
💬 Open an issue or PR
🌟 Share your favorite use cases

Let’s make AI one keystroke away.

GitHub SnapMind 👉 https://github.com/Snap-Mind/snap-mind

Building a Custom Key Binding Recorder in React

Louis Liu — Thu, 02 Oct 2025 12:31:26 +0000

I’ve been working on a desktop AI assistant — SnapMind — that lets you instantly interact with LLMs from anywhere on your system. One of the core features is triggering prompts with customizable hotkeys.

By default, the app comes with built-in hotkeys, but I wanted users to be able to define their own key bindings.

At first, I considered using a third-party library for this. But I soon realized it wasn’t too hard to build my own lightweight recorder, so I decided to implement it from scratch. In this post, I’ll share the key points of how I designed this component.

Rules

The component should allow users to provide up to 2 modifier keys and one main key. Once a valid key binding is captured, the recording should stop.

Start listening when the input is focused
The final key binding = up to 2 modifiers + 1 main key
Automatically commit once a valid combination is captured (≥1 modifier + 1 main key)
Provide a reset button to clear user inputs

States

Here’s how I structured the component’s state:

const [keybindings, setKeybindings] = useState<string | null>(null); // The final result
const [modKeys, setModKeys] = useState<Set<string>>(new Set()); // Active modifiers captured (max 2)
const [mainKey, setMainKey] = useState<string | null>(null); // Main (non-modifier) key
const [recording, setRecording] = useState(false); // Indicate recording state
const inputRef = useRef<HTMLInputElement | null>(null); // Input reference

Listen to key down

Initially, I wanted the component to display key presses in real time — for example, showing Ctrl + Shift + C when held, then Ctrl + C once Shift is released. That would have been cool, but I realized a simpler approach was enough: just capture the combination on key down and persist it until reset.

const onKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
  if (!recording || disabled || keybindings) return;
  e.preventDefault();
  const k = e.key;
  const nextMods = new Set(modKeys); // Use Set here so it won't record duplicated keys
  let nextMain = mainKey;
  if (isModifier(k)) {
    // Handle keys like Ctrl and Shift.
    const lower = k.toLowerCase();
    if (nextMods.has(lower) || nextMods.size < 2) { // We're using Set, so I don't care about capture duplicate modifiers
      nextMods.add(lower);
    }
  } else if (!nextMain && isAllowedMainKey(k)) { // I don't want to capture keys like F1~F12 and other special keys
    nextMain = k;
  }
  // Update state if changed
  if (nextMain !== mainKey) setMainKey(nextMain);
  if (nextMods.size !== modKeys.size || Array.from(nextMods).some((m) => !modKeys.has(m))) {
    setModKeys(nextMods);
  }
  // Attempt to finalize immediately once we have both parts
  attemptCommit(nextMods, nextMain);
};

Display recorded keys

Displaying the result is straightforward. I also reorder the modifiers so users won’t see something like Shift + Ctrl + C (which feels unintuitive). The captured key names from the browser event are mapped to more readable labels.

function orderModifiers(mods: string[], platform: 'mac' | 'other') {
  const rankMac: Record<string, number> = { meta: 1, shift: 2, alt: 3, control: 4 };
  const rankOther: Record<string, number> = { control: 1, shift: 2, alt: 3, meta: 4 };
  const rank = platform === 'mac' ? rankMac : rankOther;
  return [...mods].sort((a, b) => (rank[a.toLowerCase()] ?? 99) - (rank[b.toLowerCase()] ?? 99));
}

function printModifier(k: string) {
  switch (k.toLowerCase()) {
    case 'meta':
      return 'Command';
    case 'alt':
      return 'Option';
    case 'control':
      return 'Ctrl';
    case 'shift':
      return 'Shift';
    default:
      return k;
  }
}

function normalizeMain(k: string) {
  if (k.length === 1) return /^[a-z]$/i.test(k) ? k.toUpperCase() : k;
  if (/^f\d{1,2}$/i.test(k)) return k.toUpperCase();
  const map: Record<string, string> = {
    escape: 'Esc',
    ' ': 'Space',
    arrowup: 'Up',
    arrowdown: 'Down',
    arrowleft: 'Left',
    arrowright: 'Right',
    enter: 'Enter',
    tab: 'Tab',
    backspace: 'Backspace',
  };
  return map[k.toLowerCase()] || k;
}

function formatDisplay(mods: string[], main: string | null, platform: 'mac' | 'other') {
  if (!main) return orderModifiers(mods, platform).map(printModifier).join('+');
  const ordered = orderModifiers(mods, platform).map(printModifier);
  return [...ordered, normalizeMain(main)].join('+');
}

Demo

I added a 🔴 indicator to show whether the component is currently recording.

Here's the source code to the component.

A few years ago, I would have reached for a third-party library whenever I needed functionality like this. Now, with help from AI, I find it faster and cleaner to implement simple business logic myself.

If this sounds interesting, feel free to give SnapMind a try — I’d love to hear your feedback!

GitHub Repo: https://github.com/Snap-Mind/snap-mind

Letting AI Build My App's Auto Updates (and Fixing the Pitfalls)

Louis Liu — Thu, 25 Sep 2025 15:49:55 +0000

It’s been two weeks since I last shared an update about my AI assistant project — SnapMind.

The development experience was smooth with GitHub Copilot, especially when I added auto-update feature. I didn’t start by reading the Electron Updater documentation. Instead, I asked AI to generate an initial implementation for me. After I figured out how it works, I read the documentation to verify the update workflow.

Of course, not everything went perfectly. On my Apple Silicon MacBook, the auto-updater mistakenly installed the x86 version of the app instead of the ARM build. Let’s just say it was a confusing few minutes before I realized what happened 😅😂 The AI doesn't know my build artifact structure, so it didn't remind me that the Electron updater could take the wrong YAML file. Context management is crucial.

Let's take a look at the updates!

Auto Updates

Now you don’t need to manually download new installers from GitHub. You can check for and install updates directly inside the app.

More Providers

DeepSeek and Qwen are supported.

Customize Hotkeys (Beta)

You can now set your own hotkeys to trigger prompts.
This should’ve been there from the start, but I want the setup experience to feel great, so it’s still in beta for now.

Currently, beta version can only be downloaded through GitHub Release page.

There are already great desktop apps like ChatBox, DeepChat, LM Studio, and Cherry Studio. They support multiple LLMs, MCP servers, and many other advanced features.

But here’s the thing: I got tired of constantly copying and pasting text or switching apps just to ask AI a question.

SnapMind is designed to work directly with the content you already have — no extra steps, no wasted time.

🙌 I’m building SnapMind to make AI truly practical for daily workflows. What’s your use case? Share your routine in the comments — I’d love to see how SnapMind can help you. Give me a star🌟 on GitHub if you think SnapMind could help you!

Project link: https://github.com/Snap-Mind/snap-mind

Is AI Pushing Software Engineers to the Next Efficiency Test?

Louis Liu — Thu, 18 Sep 2025 12:07:10 +0000

The momentum of AI development remains strong, and it has become an unavoidable topic in our daily lives. Since AI entered our work routines, discussions about whether it might replace humans have been ongoing. In software development, this question is particularly relevant: is AI a productivity booster, or does it present new challenges for software engineers?

AI in Real-World Development Scenarios

Earlier this year, my organization purchased GitHub Copilot licenses for our team. Naturally, any investment comes with an expectation of return, so the question of “how to leverage AI to improve work efficiency” quickly became a topic on the table.

Efficiency is often measured directly: a feature that used to take a full day to develop—can it now be completed in half a day? Many imagine AI as a “magic tool” that can instantly turn any developer into an experienced engineer. Online stories often emphasize speed—people with little programming experience have used AI to quickly build a small product and even launch it.

Before seeing these cases, my view of AI was mostly positive. I enjoyed using AI to help write code because it reduces repetitive work and frees me from thinking about trivial details. But when efficiency becomes the main focus, I began to hesitate: can AI really help me deliver more within the same amount of time?

The Cost of Speed

When discussing AI-assisted coding, the first thing people mention is speed: features launch faster, iterations progress quicker, and delivery cycles shorten. But in software engineering, is speed the only metric that matters?

In a business context, software engineers typically work as part of a team, which is very different from an individual building a product from scratch. Can AI truly integrate into an existing codebase? While enjoying the benefits AI brings, we also need to consider potential risks.

Consistency: Different developers may use prompts differently, resulting in AI-generated code with inconsistent styles. Time saved in the short term may lead to long-term maintenance costs.
Dependency: Over-reliance on AI, even for simple tasks, may actually reduce overall efficiency.
Quality: AI can generate large volumes of code quickly, but these outputs still require human review. If reviews fall behind, potential issues may go unnoticed.
Accuracy: When generated code doesn’t match expectations, humans still need to refactor or regenerate it.
Maintainability: Seemingly completed features may later demand extra time for maintenance due to messy structure or poor readability.

Speed has its value, but if the focus is solely on being fast, the result may ultimately become unmanageable.

Value Beyond Speed

Many articles discussing AI-assisted development focus on rapid iteration and delivery speed. I believe it’s more important to recognize AI’s ability to help developers focus on complex problems and improve accuracy.

As noted by IBM in their AI in Software Development article:

Gen AI assists in code generation and automates repetitive coding tasks. Gen AI-powered tools help developers focus on complex problems, while AI-driven autocompletion and real-time suggestions improve speed and accuracy.

In other words, AI is not simply about “writing code faster.” Its true value lies in freeing developers from repetitive work and allowing them to focus on truly complex and creative tasks.

A Broader Perspective

Software development involves more than just the engineering team. Requirements gathering, analysis, UI/UX design, maintenance support, and product documentation can all leverage AI to improve efficiency. These areas are often overlooked, yet they represent some of the most untapped potential for AI to add value.

Defining Efficiency in Practice

So, can AI truly improve software development efficiency? This is a question that can only be answered through practice.

If we start with the assumption that “AI saves time” and work backward from there, teams may face risks. Efficiency is not just speed; it is stable delivery, consistent style, reliable quality, and maintainability over time.

Coding is not only about being “fast”; it also requires coordination and rhythm within the team. The value of AI may not lie in compressing a week’s work into three days, but in allowing developers to focus their limited energy where it matters most.

This is not the first time a method or tool has challenged team efficiency. The previous wave was agile development. Many companies, in adopting agile, focus on speed, but often simply increase pressure on the team without fully understanding agile principles. AI is similar: on the surface, it promises efficiency, but its true value lies in understanding the underlying principles and applying them thoughtfully.

AI is not a simple accelerator—it is an opportunity for us to redefine what efficiency truly means.

Reference:

IBM: AI in Software Development

Bring AI Into Any App With One Keystroke

Louis Liu — Wed, 10 Sep 2025 05:21:40 +0000

AI is powerful, but the way we interact with it still feels clunky. Most of the time, I have to open a browser or launch a desktop app, type in my question, and then copy the result back into my workflow.

I reply to numerous messages on Slack every day. If I want AI to rewrite something for me, I need to copy the text, paste it into ChatGPT, adjust the response, and then copy it back. It works—but it’s disruptive.

What if AI could be just one keystroke away, seamlessly integrated into whatever I’m doing? That’s the idea behind SnapMind.

What’s SnapMind?

SnapMind is a desktop AI assistant that brings LLMs anywhere in your system. Just select text + hit a hotkey, and you can instantly:

Translate
Rewrite
Summarize
Explain

— all without leaving the app you’re working in.

In short: it’s a quick prompt launcher for your daily workflow.

Demo

Bind your favorite prompts to hotkeys, and trigger them instantly on selected text.

Features

⚡ Blazing Fast — AI in a single keystroke
🎯 Seamless Experience — Works in any app without breaking your flow
🛠 Highly Customizable — Save prompts for the tasks you do most

Use Cases

🌍 Instant Translation — Translate any text on the fly
✍️ Polish & Rewrite — Make content clearer, shorter, or more professional
📑 Summarize in Seconds — Get key takeaways from long reports
💡 Quick Explanations — Highlight concepts, code, or terms for clarity
📬 Smart Drafting — Generate emails, replies, or snippets in seconds
📚 Learning Companion — Check grammar, simplify content, aid understanding
🧠 On-the-fly Brainstorming — Turn raw notes into structured thoughts

What’s Next?

Here’s what’s coming to SnapMind:

🔗 Support for more AI providers (OpenAI, Azure OpenAI, Anthropic, Google AI — with more on the way)
🖼️ Image input/output: select an image and send it to AI or ask AI created an image for you.
📝 Better markdown rendering for easy copy & paste
🔄 Auto-updates via Electron Builder
...

I’d love to hear from you:

What use cases do you want SnapMind to support?
Do you have cool workflows or scenarios where SnapMind could made you more productive?

👉 Try it now at Github - SnapMind. ⭐️ It will very be helpful if you can give the repo a star! ⭐️

3-Minute Guide: Make GitHub Copilot Generate High-Quality Code

Louis Liu — Thu, 04 Sep 2025 03:18:36 +0000

GitHub Copilot allows you to customize its behavior by adding Markdown files to your .github folder in a Git repository. There are three types of files you can add:

Instructions – guide Copilot on your coding preferences
Prompts – reusable prompt templates
Chat Modes – customized modes for different tasks

1. Instructions

Instruction files let you provide Copilot with guidance and preferences.

Create a copilot-instructions.md file in the .github folder:

# Copilot Instructions

## General Guidelines

- Follow the instructions in the instructions folder whenever possible.
- File Changes: Only edit files when you have full context. Prefer reading large sections of code before making changes.
- ...

## Workflow

...

## Coding Standard

...

This file will automatically bring the instructions into your chat context.

You can also create path-specific instruction files (xxx.instructions.md) inside .github/instructions.

---
applyTo: "**/*.ts,**/*.tsx"
---

This ensures instructions only apply to the files you specify.

2. Prompts

Prompt files allow you to create reusable prompts.

Create an xxx.prompt.md file in .github/prompts:

---
mode: 'agent'
model: GPT-4o
tools: ['githubRepo', 'codebase']
description: 'Generate a new React form component'
---
Your goal is to generate a new React form component based on the templates in #githubRepo contoso/react-templates.

Ask for the form name and fields if not provided.

Requirements:
* Use form design system components: [design-system/Form.md](../docs/design-system/Form.md)
* Use `react-hook-form` for form state management
* Always define TypeScript types for your form data
* Prefer *uncontrolled* components using `register`
* Use `defaultValues` to prevent unnecessary rerenders
* Use `yup` for validation
* Create reusable validation schemas in separate files
* Use TypeScript types to ensure type safety
* Customize UX-friendly validation rules

To use it, type / followed by the prompt file name in the chat window.

3. Chat Modes

Create an xxx.chatmode.md file in .github/chatmodes:

---
description: Generate an implementation plan for new features or refactoring existing code.
tools: ['codebase', 'fetch', 'findTestFiles', 'githubRepo', 'search', 'usages']
model: Claude Sonnet 4
---
# Planning mode instructions
You are in planning mode. Your task is to generate an implementation plan for a new feature or for refactoring existing code.
Do not make any code edits; just generate a plan.

The plan should include:

* **Overview** – brief description of the feature or task  
* **Requirements** – list of requirements  
* **Implementation Steps** – detailed step-by-step plan  
* **Testing** – tests to verify the implementation

You can select your custom chat mode in the chat window.

Summary

You don’t need to create these files from scratch. Awesome Copilot provides many templates—you just need to copy them into your project as needed.

References

Hello Monday

Louis Liu — Mon, 28 Jul 2025 01:59:55 +0000

Another tough week, but seeing the high-five Octocat at the bottom of the pull request gave me a bit of relief.

Hope y’all have a smooth week—no bugs, no blockers!