How to Build

This isn’t about side hustles or startups - this is about publishing something you’ve built and owning it. Whether it’s a Bash script, Python app, or full-on internal tool, this guide walks you through how to properly stand it up as a public project on GitHub.

We already covered how to stand up your personal site - this page is about how to build and publish your project. Then later, you can write a blog post about it and/or make a video walkthrough.

Step 1: Get Set Up on GitHub

Before you write any code, let’s get the foundation right.

• Use a GitHub Organization, if you want to keep personal and project stuff separate.

  • Example: github.com/[OrgName]/[RepoName]
  • If your GitHub username is your brand, you can use that too. If your GitHub username is samueljwalton and your brand is WaltonSecurity, that’s not great from a privacy perspective. Instead, it would be ideal to create a username of WaltonSecurity and use that as your GitHub org. Meaning, you might have a GitHub repo of https://github.com/WaltonSecurity/aws-tools. And when people go to it, they will see commits done by WaltonSecurity instead of your personal username.

• Create a new repo

  • Give it a clean, short name. Ask ChatGPT:
    "Suggest a name for a GitHub repo that contains a Bash script for monitoring EC2 CPU usage."

Step 2: SSH Setup

You’ll want to connect to GitHub using SSH. That gives you two big benefits:

1. Authentication: Secure authentication
2. Signing: The ability to sign commits with your SSH key (instead of fiddling with GPG)

Where SSH keys live

• Windows: C:\Users\[Username]\.ssh\
• macOS/Linux: ~/.ssh/

Create a keypair if you don’t have one (in the folder above):

# Create a new SSH key
ssh-keygen -t ed25519 -C "[email protected]"

Then, add the public key to your GitHub account:

cat ~/.ssh/id_ed25519.pub

Copy the output, then go to GitHub:

https://github.com/settings/keys

Add your public key for “Authentication” and then again for “Signing”.

Resources for SSH Setup

• Add SSH Key to GitHub
• Your GitHub SSH Key Settings

Step 3: Set Your Git Identity

In your terminal, run:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Step 4: Enable SSH Commit Signing

This makes every commit verifiable, with no GPG headaches. This means that when you create a commit, you are digitally signing it with your SSH key, which GitHub can now verify because you’ve added the public key to your account.

This proves that the commits came from you, and will show a “Verified” badge on GitHub too. In your terminal:

git config --global gpg.format ssh
git config --global user.signingkey "$(cat ~/.ssh/id_ed25519.pub)"
git config --global commit.gpgsign true

In VS Code, go to:

• Settings -> Search for git.enableCommitSigning or “Git: Enable Commit Signing” or click here to open it directly.
• Make sure it’s enabled

Step 5: Clone Your Repo

The idea here is to clone your GitHub repo to a local folder where you can work on it. There is a hidden .git folder inside your local folder that tracks all the changes you make. It also keeps track of where it came from, or the “remote” repo on GitHub. Once cloned, you can do something like git remote get-url origin to see that mapping.

Use SSH to clone:

# Clone a repository from GitHub to your local folder
git clone [email protected]:[OrgName]/[RepoName].git ~/gitlocal/[OrgName]/[RepoName]

That folder structure mirrors the GitHub URL. This is helpful once you work with more and more GitHub repos.

Then:

# Change into the repo directory
cd ~/gitlocal/[OrgName]/[RepoName]

# Open the repo in Visual Studio Code
code .

Step 6: Set Up Your Repo

Some best practices from the start:

• Source should go under src/, not the root
• Add a README.md right away. GitHub will display this automatically.
• Use gitignore.io to generate your .gitignore:
  • Example terms: windows, macos, linux, git, node, python, venv, dotenv

For more, see: HOWTO: Open Source. Even if this particular project will be a private repo, these are best-practices that still apply.

Step 7: Add Your Code

Let’s say you’re writing a Bash script:

mkdir -p src/
touch src/watch_rds_cpu.sh

Write your script, and then let GitHub Copilot help:

“Act as an experienced engineer in bash scripting who is meticulous about best-practices. Please review and correct this script, without breaking any existing functionality. This includes things like: input validation, error handling, showing output to the user for info, warn, and errors, and include a --help screen that shows how to use the script.”

Then ask Copilot again:

“Please generate a high-quality README.md for this GitHub repository and scripts. This should include what the script does, any prerequisites and include some example usage.”

Step 8: Commit and Push

When you’re happy with the state of things, you can create a commit to save these changes from your local copy of the repo, and then push those changes to the remote repo on GitHub.

Stage and sign your first commit:

git add .
git commit -S -m "Initial commit"
git push origin main

Or within VS Code, you can just use the “Source Control” panel:

Once pushed, visit your repo on GitHub github.com/[OrgName]/[RepoName] to make sure everything looks right. Once that’s working, the rest is rinse-and-repeat:

• Make changes
• Commit + push
• Repeat

Next Step:

Publish Your Work ->

Once it’s live, don’t just let it sit there. Write a blog post about it, share it with your network, and maybe even make a video walkthrough. The rest of this site covers how to do all that.

Summary

• Set up your SSH key once, and use it for both login and signing
• Use a smart folder structure to keep projects organized
• Never check in secrets - use .env files instead
• Let GitHub Copilot help with code and docs
• Push early, push often - and keep iterating

Your GitHub repos are your portfolio. Build something worth sharing.