DEV Community: Cristian Jonhson Alvarez

Reset, revert, and reflog: the ultimate guide to undoing commits without losing your repo

Cristian Jonhson Alvarez — Wed, 10 Jun 2026 20:56:25 +0000

😰 Story time: I ran git reset --hard HEAD~1, force pushed… and then realized I needed that file back.

TL;DR

Not pushed yet → reset
Pushed + shared branch → revert
“Lost” a commit → git reflog

The real-world scenario

You’re working on a repo and you create commits like:

chore: remove compiled artifacts from the repository
chore: add .gitignore to exclude unnecessary files

Then you try to undo the last commit, you run push --force-with-lease, and later you say:

“I need to recover that file.”

Let’s go step by step.

1) Undo the last commits: reset vs revert

Rule of thumb:

✅ Working alone / not pushed yet → use reset
👥 Shared branch / already pushed → use revert

Before you copy/paste commands, get your current branch name:

git branch --show-current

Use that value wherever you see YOUR_BRANCH.

Option A: `reset` (rewrites history)

Useful when you want those commits to disappear from the history.

Deletes commits and discards changes (hard mode):

git reset --hard HEAD~2

Deletes commits but keeps changes staged (soft mode):

git reset --soft HEAD~2

GitHub note (force push): If you already pushed, to make the remote match you must force push.

Avoid --force and use:

git push --force-with-lease origin YOUR_BRANCH

✅ --force-with-lease is safer because it won’t overwrite remote work you don’t have locally.

⚠️ If the branch is protected (common on main/master), GitHub may block force pushes.

Example:

git push --force-with-lease origin master

Option B: `revert` (does NOT rewrite history)

Recommended when:

Other people are working on the repo
The branch is shared
The branch is protected (e.g., main/master)

It creates new commits that undo the changes:

git revert --no-edit HEAD~2..HEAD
git push origin YOUR_BRANCH

2) Recover commits after `reset --hard` with `reflog`

If you ran:

git reset --hard HEAD~1

and then regretted it, your lifeline is:

git reflog

Real example output:

dc65430 HEAD@{0}: reset: moving to HEAD~1
3bfb189 HEAD@{1}: commit: chore: add .gitignore to exclude unnecessary files
dc65430 HEAD@{2}: commit: chore: remove compiled artifacts from the repository

You can see the “lost” commit still exists: 3bfb189.

To return to that state:

git reset --hard 3bfb189

If you also want GitHub to match:

git push --force-with-lease origin YOUR_BRANCH

3) Restore a specific file from an earlier commit

Sometimes you don’t want to move the whole branch—only recover one file that existed in a past commit.

Important

This command always requires a path:

git restore --source <COMMIT> -- <FILE_PATH>

Common example: restore .gitignore from 3bfb189:

git restore --source 3bfb189 -- .gitignore

Then save it in history:

git add .gitignore
git commit -m "chore: restore .gitignore"
git push origin YOUR_BRANCH

Don’t know the exact file path?
List the files touched by that commit:

git show --name-status --pretty="" 3bfb189

Or list everything that exists in that commit:

git ls-tree -r 3bfb189 --name-only

Once you find the exact path, restore it:

git restore --source 3bfb189 -- real/path/to/file.ext

Restore EVERYTHING from a commit (warning: overwrites)

⚠️ This can overwrite local changes in your working tree:

git restore --source 3bfb189 -- .

4) Change the last commit message

If you have NOT pushed yet

git commit --amend -m "new message"

If you ALREADY pushed to GitHub

git commit --amend -m "new message"
git push --force-with-lease origin YOUR_BRANCH

5) Tips to avoid Git pain (seriously)

Before doing an aggressive reset, create a “backup branch”:

git branch backup-before-reset

Prefer --force-with-lease over --force
If you’re working with a team, prefer revert over reset
reflog is your “secret history”: when something “disappears”, check git reflog

Wrap-up

If you ever feel like you “lost” commits or files, remember:

git reflog finds the commit you can’t see anymore
git restore --source restores specific files without breaking everything
reset rewrites history (requires force push)
revert is team-friendly

Your turn 👻

What’s your worst Git mistake? Did you manage to recover it, or did you have to start over? Drop your story in the comments.

How to Create a GitHub Repository from the Terminal Using GitHub CLI

Cristian Jonhson Alvarez — Wed, 10 Jun 2026 20:44:15 +0000

When working on a local project, we usually create the repository on GitHub first, copy the remote URL, and then connect it to our local project.

But there is a cleaner way to do it directly from the terminal using GitHub CLI.

1. Initialize Git in Your Project

Go to your project folder:

cd your-project-name

Initialize Git:

git init

2. Authenticate with GitHub CLI

If you have not logged in yet, run:

gh auth login

During the process, you can choose:

GitHub.com
SSH
Login with a web browser

3. Create the Remote Repository from Local

To create the repository on GitHub and add it as origin, run:

gh repo create repository-name --public --source=. --remote=origin

Example:

gh repo create IA_ML_DL_python_fundamentos --public --source=. --remote=origin

For a private repository:

gh repo create repository-name --private --source=. --remote=origin

4. Verify the Remote

Check that origin was added correctly:

git remote -v

You should see something like:

origin  git@github.com:username/repository-name.git (fetch)
origin  git@github.com:username/repository-name.git (push)

5. Create the First Commit

Add your files:

git add .

Create the first commit:

git commit -m "Initial commit"

6. Push the Project to GitHub

Make sure your main branch is named main:

git branch -M main

Push your project:

git push -u origin main

Full Command Summary

git init
gh auth login
gh repo create repository-name --public --source=. --remote=origin
git add .
git commit -m "Initial commit"
git branch -M main
git push -u origin main

Conclusion

Using gh repo create allows you to create a GitHub repository directly from the terminal, connect it as origin, and push your local project without manually creating the repository from the browser.

It is a faster, cleaner, and more professional workflow for starting new projects on GitHub.

Getting Started with AWS: A Practical Guide for Beginners

Cristian Jonhson Alvarez — Mon, 06 Jan 2025 18:28:52 +0000

By the end, you’ll know exactly what to learn first on AWS—and you’ll have 2 mini-projects to prove it.

✅ Plus: you’ll set up Budgets on day one to avoid surprise costs.

TL;DR

Start with EC2, S3, IAM, RDS
Build 1–2 tiny projects (static website + simple API)
Keep costs under control from day one (Budgets + Free Tier)
✅ “Set up AWS Budgets on day 1 to avoid surprise bills.”

1. What is AWS, and why should you learn it?
2. Create your AWS account (and avoid surprise costs)
3. Get familiar with the AWS Console
4. Learn the core services (first 4)
5. Build your first projects
6. Training and certifications
7. Join the community
8. Final tips
Conclusion

1. What is AWS, and why should you learn it?

AWS is a set of cloud services that lets you build and run applications without managing physical servers.

Why learn AWS?

Job opportunities: AWS skills are in high demand across dev, DevOps, data, and security.
Versatility: You can build websites, APIs, databases, analytics, CI/CD, and more.
Pay-as-you-go: You can start small and only pay for what you use.

2. Create your AWS account (and avoid surprise costs)

To start, you need an AWS account:

Go to https://aws.amazon.com/
Click Create a Free Account
Register with email + credit card (AWS uses it for verification and billing)

✅ Cost safety tip (do this immediately):

Set up AWS Budgets and billing alerts the same day you create the account.

Example:

“Go to Billing → Budgets → Create budget (monthly)”.

Free Tier basics

AWS offers a Free Tier for many services (some are 12 months, some always-free, some trials).
Always check pricing pages before creating resources.

3. Get familiar with the AWS Console

The AWS Management Console is where you’ll create and manage services.

Spend time on:

Navigating services (search bar is your best friend)
Switching regions (top-right)
Understanding IAM users/roles (more below)

Pro tip: Learn the AWS CLI once you’re comfortable in the console:

aws --version
aws sts get-caller-identity

4. Learn the core services (first 4)

If you only learn these 4 first, you’ll already understand most AWS basics.

4.1 EC2 (Elastic Compute Cloud)

Virtual servers in the cloud.

Practice:

Launch an instance (Amazon Linux / Ubuntu)
Connect via SSH
Stop/terminate it to avoid costs

⚠️ Reminder: Stop/terminate your instance when done.

4.2 S3 (Simple Storage Service)

Object storage for files (images, backups, static websites).

Practice:

Create a bucket
Upload/download files
Learn permissions (private vs public)

4.3 RDS (Relational Database Service)

Managed databases (PostgreSQL, MySQL, etc).

Practice:

Create a small PostgreSQL instance (Free Tier eligible if available)
Connect from local app
Learn basics: security groups + subnet groups

4.4 IAM (Identity and Access Management)

Users, roles, permissions.

Practice:

Create an IAM user with least privilege
Create an IAM role (used by EC2/Lambda)
Learn policies (managed vs inline)

🔥 If you learn IAM early, you’ll avoid most “why is access denied?” pain later.

5. Build your first projects

The fastest way to learn AWS is to build.

Project 1: Static website with S3 + CloudFront

Goal: host a simple website (HTML/CSS/JS) in S3 and deliver it via CDN.

Steps:

Upload site files to S3
Configure static hosting (or private bucket + CloudFront)
(Optional) Add a custom domain with Route 53

Project 2: Serverless API with Lambda + API Gateway

Goal: create a tiny API endpoint (e.g., /hello) without managing servers.

Steps:

Create a Lambda function (Node/Python)
Expose it via API Gateway
Test it with curl/Postman

6. Training and certifications

If you want a structured path:

AWS Skill Builder (official training)
AWS Docs (learn service-by-service)
YouTube channels / labs / hands-on projects

A common first cert:

AWS Certified Cloud Practitioner (CLF)

7. Join the community

Learning is easier with people:

AWS re:Invent sessions (even recorded ones)
Local meetups
DEV posts / discussions / GitHub projects

8. Final tips

Go one service at a time — don’t try to learn everything.
Document your progress — keep a repo or a DEV series.
Turn things off — most surprise bills come from resources left running.
Security mindset early — IAM + least privilege always.

Conclusion

AWS is huge, but starting doesn’t have to be complicated.

If you focus on the core services and build 1–2 small projects, you’ll quickly feel confident navigating AWS.

Your turn 👇

What was the first AWS service that “clicked” for you? - And what’s the best beginner project to learn it?

DEV Community: Cristian Jonhson Alvarez

Reset, revert, and reflog: the ultimate guide to undoing commits without losing your repo

The real-world scenario

1) Undo the last commits: reset vs revert

Option A: reset (rewrites history)

Option B: revert (does NOT rewrite history)

2) Recover commits after reset --hard with reflog

3) Restore a specific file from an earlier commit

Important

Restore EVERYTHING from a commit (warning: overwrites)

4) Change the last commit message

If you have NOT pushed yet

If you ALREADY pushed to GitHub

5) Tips to avoid Git pain (seriously)

Wrap-up

Your turn 👻

How to Create a GitHub Repository from the Terminal Using GitHub CLI

1. Initialize Git in Your Project

2. Authenticate with GitHub CLI

3. Create the Remote Repository from Local

4. Verify the Remote

5. Create the First Commit

6. Push the Project to GitHub

Full Command Summary

Conclusion

Getting Started with AWS: A Practical Guide for Beginners

Table of contents

1. What is AWS, and why should you learn it?

2. Create your AWS account (and avoid surprise costs)

3. Get familiar with the AWS Console

4. Learn the core services (first 4)

4.1 EC2 (Elastic Compute Cloud)

4.2 S3 (Simple Storage Service)

4.3 RDS (Relational Database Service)

4.4 IAM (Identity and Access Management)

5. Build your first projects

Project 1: Static website with S3 + CloudFront

Project 2: Serverless API with Lambda + API Gateway

6. Training and certifications

7. Join the community

8. Final tips

Conclusion

Your turn 👇

Option A: `reset` (rewrites history)

Option B: `revert` (does NOT rewrite history)

2) Recover commits after `reset --hard` with `reflog`