How to develop in 2025: Improve your Workflow with VS Code, GitHub & Copilot

VS Code Workspace Settings

Shortcuts

First of all, I strongly suggest adding some custom shortcuts because the default ones are a bit unintuitive. For example, CTRL + SHIFT + ' gets you to the terminal, while SHIFT + FN + F6 brings you back to the editor, andSHIFT + B opens the sidebar. What a mess! A more consistent setup can definitely improve your workflow.

To customize your shortcuts, press CMD + K followed by CMD + S or look up “Keybindings” in the command palette (SHIFT + CMD + P). There’s a small icon on the right to open the actual JSON file, which makes configuration much easier. What about jumpin between the sidebar, editor, and terminal using the arrow keys while holding CTRL + SHIFT?

[
    {
        "key": "ctrl+shift+down",
        "command": "workbench.action.terminal.focus"
    },
    {
        "key": "ctrl+shift+up",
        "command": "workbench.action.focusActiveEditorGroup"
    },
    {
        "key": "ctrl+shift+left",
        "command": "workbench.action.focusActivityBar"
    }
]

Add more shortcuts to make your mouse-less life easier. But thats not all, I also suggest to use a tool like Espanso! It’s a very powerfull text expander with two main interesting features:

if you start typing certin chars, it will automaticall expand them to something you configured
it also provides a quick search feature that you can trigger with OPTION + SPACE

So here’s my strategy, let’s take some Python commands for example. I am not using unique trigger keywords, but the same one to define particular categories (see a full example at this Gist)

matches:
  - trigger: "#p1"
    replace: "source .venv/bin/activate"
  - trigger: "#p"
    replace: "python3 -m venv ./.venv"
  - trigger: "#p"
    replace: "pip3 install -r requirements.txt"
  - trigger: "#p"
    replace: "pip3 freeze > requirements.tx"

When I open the quick search bar, I type #p to get all Python commands. Ofcourse you could also add unique trigger keywords, I prefer it like that because I don’t remember all those keywords anywawys. Now I can just show quickly browse through commands for a given category, like JavaScript, Python, C# - you name it!

Containers

Warning: Requires Docker!

Next, let’s talk about containers! I strongly recommend using containers for your projects. Not all of them, of course, sometimes a virtual environment is totally sufficient. But containers! Oh boy! They are quick, easy, and help keep your system clean. VS Code allows you to set up dev containers—a closed ecosystem where you can configure your development environment. This is especially useful when switching between different languages, frameworks, or systems.

For example, if you want to test Ruby without installing all the dependencies on your system, create a .devcontainer folder within your workspace and place two files in it: devcontainer.json and Dockerfile.

Example Setup for Ruby:

`Dockerfile`

FROM ruby:3.2
ENV LANG=C.UTF-8
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y build-essential git curl zlib1g-dev \
    libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 nodejs && \
    rm -rf /var/lib/apt/lists/*
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=$USER_UID
RUN groupadd --gid $USER_GID $USERNAME
RUN useradd --uid $USER_UID --gid $USER_GID -m $USERNAME
USER $USERNAME
WORKDIR /workspace
RUN gem install bundler
EXPOSE 3000
CMD ["irb"]

`devcontainer.json`

{
    "name": "Ruby Development",
    "build": {
        "dockerfile": "Dockerfile",
        "args": {
            "USER_GID": "1000",
            "USER_UID": "1000",
            "USERNAME": "vscode"
        }
    },
    "settings": {
        "terminal.integrated.defaultProfile.linux": "bash"
    },
    "extensions": [
        "rebornix.ruby",
        "castwide.solargraph"
    ],
    "postCreateCommand": "bundle install",
    "remoteUser": "vscode"
}

Save everything, and VS Code will prompt you to create and open the dev container—no need to manage Docker manually! If you don’t see the message, open the “Remote” container manually by clicking the blue icon in the bottom left corner or using the shortcut OPT + COMMAND + O.

Git

You don’t necessarily need a GitHub account to store repositories remotely, but I encourage initializing a repository locally. This helps you track changes and maintain your work efficiently.

Configuring Multiple GitHub Accounts

If you use different GitHub accounts (e.g., for personal and professional projects), modify your Git config file:

[user]
    name = John Doe
    email = john.doe@example.com

Branching Strategy

If you don’t use Git daily, consider a simple branch strategy:

Use the main branch for stable code.
Use a debug branch for hotfixes or minor fixes.
Use a dev branch for new features.

Example Workflow:

git checkout dev
git pull origin main
# Make changes
git commit -m "Your commit message"
git push origin dev

Once you’re ready to merge changes:

git checkout main
git merge dev
git push origin main

This keeps your codebase organized and reduces conflicts. If needed, Copilot can assist with Git commands!

Copilot

Copilot enhances your workflow with:

Inline code completion
Inline chat (CMD + I)
An editor that handles multiple files (CMD + SHIFT + I)
General assistance via chat
Commit message suggestions

Improving Copilot’s Effectiveness

To help Copilot assist you better:

Use meaningful function names.
Add inline comments.
Write clean, structured code.

Customizing Copilot

You can fine-tune Copilot’s behavior by modifying your workspace settings. Create a settings.json file inside the .vscode folder and add custom configurations.

Example Settings:

"github.copilot.chat.localeOverride": "fr",
"github.copilot.chat.commitMessageGeneration.instructions": [
    {"instruction": "Start every commit message with FOOBAR"}
],
"github.copilot.chat.codeGeneration.useInstructionFiles": true

Now, create a ./.github/copilot-instructions.md file with your custom instructions. Example:

- My project goal is a simple and performant API interface.
- Code must follow modern coding standards.
- Functions should have a maximum of 20 lines.
- No redundant functions.
- Each function must have a corresponding test function.
- Include example data for testing.
- Use multiple files, grouping functions logically.
- Prefer class-based structures over standalone functions.

Finding More Rule Sets

For additional guidance, check these resources:

Claude, ChatGPT, Gemini, and Probably Even v0!

It doesn’t end with Copilot. And again: You can achieve a lot with free plans! But if you really want to improve your process and build big things, consider using LLMs.

Before diving in, heads up: Don’t make the same mistake as this poor guy:

Guys, I’m under attack ever since I started sharing how I built my SaaS using Cursor. Random things are happening—maxed-out usage on API keys, people bypassing the subscription, creating random stuff in the database.

Don’t expect an LLM to generate a perfect app if you just throw some poorly written sentences at it. Garbage in, garbage out. So, what should you do instead? Chain it!, baby.

Start simple.
Iterate.
Split your project into independent parts.

Think about developing an Android App for example. How would a human developer approach the task, what information would be required?

The overall concept: What is the app about? What language is it written in? Let’s call it the “soul”
The UI/UX concept: How should it look and feel? The “body”!
And, to stick to the image: The “viscera”: The architecture, functions, features and internal structure.

Now, ask ChatGPT to consider this “trinity” and generate three structured pre-prompt instructions for you.

In Copilot, use the soul prompt in your pre-prompt instructions, as mentioned above.
Then, feed the body and viscera prompts into Copilot, Claude, or v0 to refine the results further.

Of course, this isn’t a cut into stone,but it should give you a structured approach to leveraging AI effectively.

But do not forget this: AI Is a Tool, Not a Magic Wand. Don’t take AI-generated results for granted. The golden rule from the early internet days still applies:

“A computer is only as smart as the person using it.”

Always question and understand the output. Don’t expect AI to perfectly execute any task instantly and without errors. Because: The developer is still you.