DevCheats

git clone <repo-url>

git clone --depth 1 <repo-url>

git clone -b <branch> <repo-url>

git init

git status

git status -s

git add .

git add <file>

git add -p

git commit -m "message"

git commit --amend -m "new message"

git commit --amend --no-edit

git commit -am "message"

git commit --allow-empty -m "trigger CI"

git push origin <branch>

git push --force-with-lease

git push -u origin <branch>

git push --all

git pull

git pull --rebase

git pull origin <branch>

git fetch --all

git fetch --prune

git checkout -b <branch>

git checkout <branch>

git switch <branch>

git switch -c <branch>

git branch -a

git branch --merged

git branch -d <branch>

git branch -D <branch>

git push origin --delete <branch>

git branch -m <new-name>

git merge <branch>

git merge --no-ff <branch>

git merge --abort

git merge --squash <branch>

git rebase <branch>

git rebase -i HEAD~<n>

git rebase --abort

git rebase --continue

git rebase --onto <new> <old> <branch>

git stash

git stash push -m "message"

git stash -u

git stash pop

git stash list

git stash apply stash@{n}

git stash drop stash@{n}

git stash clear

git log --oneline

git log --oneline --graph --all

git log -n <number>

git log --author="name"

git log --since="2024-01-01"

git log --follow -p <file>

git show <commit>

git show --stat <commit>

git reset --hard HEAD

git reset --soft HEAD~1

git reset HEAD~1

git reset HEAD <file>

git restore <file>

git restore --staged <file>

git revert <commit>

git cherry-pick <commit>

git cherry-pick -n <commit>

git diff

git diff --staged

git diff <branch1>..<branch2>

git diff --stat

git diff --word-diff

git blame <file>

git tag <tagname>

git tag -a v1.0 -m "message"

git push --tags

git tag -d <tagname>

git push origin :refs/tags/<tag>

git tag -l

git remote -v

git remote add <name> <url>

git remote remove <name>

git remote set-url origin <url>

git clean -fd

git clean -fdn

git bisect start

git bisect good / git bisect bad

git bisect reset

git reflog

git worktree add <path> <branch>

git worktree list

git submodule add <url>

git submodule update --init --recursive

git submodule status

git config --global user.name "Name"

git config --global user.email "email"

git config --list

git config --global init.defaultBranch main

git config --global help.autocorrect 1

git config --global core.excludesfile ~/.gitignore_global

git rev-parse --short HEAD

git rev-list --count HEAD

git archive --format=zip HEAD > archive.zip

git log --grep="keyword"

git diff-tree --no-commit-id --name-only -r <commit>

git shortlog -sn -- <file>

ls -la

ls -lah

ls -lt

ls -lS

tree -L 2

tree -d -L 3

cd <path>

cd ~

cd -

pwd

mkdir -p <dir>

touch <file>

rm <file>

rm -rf <dir>

cp <src> <dest>

cp -r <src> <dest>

mv <src> <dest>

cat <file>

cat file1 file2 > combined

cat -n <file>

less <file>

head -n 20 <file>

tail -n 20 <file>

tail -f <file>

wc -l <file>

grep -r "pattern" <dir>

grep -ri "pattern" <dir>

grep -rn "pattern" .

grep -C 3 "pattern" <file>

grep -r --exclude-dir=node_modules "pattern" .

rg "pattern" --type ts

find . -name "*.ext"

find . -type f -name '*.log'

find . -name '*.tmp' -delete

find . -size +100M

find . -mmin -60 -type f

find . -name '*.js' -exec wc -l {} +

fd -e ts -e tsx

curl -O <url>

wget <url>

curl -H 'Authorization: Bearer <token>' <url>

curl -X POST -H 'Content-Type: application/json' -d '{"key":"val"}' <url>

curl -L <url>

curl -v <url>

curl -o output.txt <url>

ssh user@host

ssh -i key.pem user@host

ssh -L 8080:localhost:80 user@host

ssh -R 9090:localhost:3000 user@host

scp file user@host:/path

scp user@host:/path/file .

rsync -avz src/ user@host:/dest/

rsync -avzn src/ dest/

chmod 755 <file>

chown user:group <file>

chmod +x <file>

chmod -R 644 <dir>

tar -czf archive.tar.gz <dir>

tar -xzf archive.tar.gz

tar -tzf archive.tar.gz

zip -r archive.zip <dir>

unzip archive.zip

du -sh <dir>

du -sh */ | sort -rh

df -h

free -h

uname -a

cat /etc/os-release

lscpu

top

htop

btm

kill -9 <pid>

killall <name>

lsof -i :<port>

ps aux | grep <name>

watch -n 1 <command>

<command> &

nohup <command> &

jobs

fg %1

<command> > output.txt

<command> >> output.txt

<command> 2> errors.txt

<command> &> all.txt

<cmd1> | <cmd2>

<command> | tee output.txt

history

history | grep <term>

Ctrl+R

history -c

!!

!<number>

export VAR=value

echo $VAR

env

unset VAR

source ~/.bashrc

alias ll='ls -la'

which <command>

type <command>

netstat -tlnp

ss -tlnp

nslookup <domain>

dig <domain>

ping -c 4 <host>

traceroute <host>

curl ifconfig.me

hostname -I

sed -i 's/old/new/g' <file>

sed -i '1,5d' <file>

awk '{print $1}' <file>

awk -F: '{print $1}' /etc/passwd

cut -d',' -f1,3 <file>

sort <file>

sort -n <file>

sort <file> | uniq

sort <file> | uniq -c | sort -rn

echo 'a b c' | xargs -n1

cat files.txt | xargs -P 4 -I {} cmd {}

ln -s <target> <link>

date

date +%Y-%m-%d_%H%M%S

cal

date +%s

ssh-keygen -t ed25519 -C "email"

ssh-add ~/.ssh/id_ed25519

sha256sum <file>

md5sum <file>

echo -n 'text' | base64

echo 'encoded' | base64 -d

openssl rand -hex 32

uuidgen

cat data.json | jq .

cat data.json | jq '.key'

crontab -e

crontab -l

systemctl status <service>

sudo systemctl restart <service>

sudo systemctl enable <service>

journalctl -u <service> -f

screen -S <name>

tmux new -s <name>

tmux attach -t <name>

tmux ls

Ctrl+B %

Ctrl+B "

diff <file1> <file2>

diff -y <file1> <file2>

colordiff <file1> <file2>

file <file>

stat <file>

who

uptime

xxd <file> | head

npm init -y

npm install

npm install <package>

npm install -D <package>

npm install -g <package>

npm install <package>@1.2.3

npm uninstall <package>

npm run <script>

npm run dev

npm run build

npm test

npm test -- --watch

npm update

npm outdated

npm audit

npm audit fix

npm list --depth=0

npm list -g --depth=0

npm info <package>

npm view <package> versions

npm cache clean --force

npx <package>

npx <package>@latest

npm create vite@latest my-app

npx create-next-app@latest

npm create astro@latest

npm create svelte@latest my-app

npx create-remix@latest

npx nuxi init my-app

npm create t3-app@latest

npm publish

npm publish --dry-run

npm login

npm whoami

npm link

npm unlink <package>

npm pack

npm version patch

npm version minor

npm version major

npm ci

npm dedupe

npm explain <package>

yarn add <package>

yarn add -D <package>

yarn remove <package>

yarn install

yarn upgrade

yarn upgrade-interactive

yarn why <package>

pnpm install

pnpm add <package>

pnpm add -D <package>

pnpm remove <package>

pnpm store prune

pnpm why <package>

bun install

bun add <package>

bun add -D <package>

bun run <script>

bun create <template>

bun test

bun build ./src/index.ts --outdir ./dist

node -v

npm -v

nvm use <version>

nvm install <version>

nvm ls

nvm alias default <version>

volta install node@<version>

volta pin node@<version>

npm init --scope=@org

npm config set registry <url>

docker build -t <name> .

docker build --no-cache -t <name> .

docker build --build-arg KEY=val -t <name> .

docker build --target production -t <name> .

docker build --platform linux/amd64 -t <name> .

docker buildx build --platform linux/amd64,linux/arm64 -t <name> --push .

docker run -d -p 3000:3000 <image>

docker run -it <image> bash

docker run -e KEY=val <image>

docker run -v /host:/container <image>

docker run --name <name> <image>

docker run --rm <image>

docker run --env-file .env <image>

docker run --network <name> <image>

docker run -m 512m <image>

docker run --cpus=2 <image>

docker run --restart unless-stopped <image>

docker ps

docker ps -a

docker ps -q

docker stop <id>

docker stop $(docker ps -q)

docker start <id>

docker restart <id>

docker rm <id>

docker container prune

docker rm -f <id>

docker images

docker rmi <image>

docker image prune

docker rmi $(docker images -q)

docker pull <image>

docker push <image>

docker tag <image> <repo>:<tag>

docker history <image>

docker exec -it <id> bash

docker exec -it -u root <id> bash

docker logs <id>

docker logs -f <id>

docker logs --since 1h <id>

docker logs -t <id>

docker inspect <id>

docker inspect -f '{{.NetworkSettings.IPAddress}}' <id>

docker cp file <id>:/path

docker cp <id>:/path file

docker stats

docker top <id>

docker diff <id>

docker commit <id> <new-image>

docker wait <id>

docker rename <old> <new>

docker compose up -d

docker compose up -d --build

docker compose up -d <service>

docker compose down

docker compose down -v

docker compose down --rmi all

docker compose logs -f

docker compose logs -f <service>

docker compose ps

docker compose exec <service> bash

docker compose restart <service>

docker compose pull

docker compose build

docker compose up -d --scale <service>=3

docker compose config

docker compose top

docker volume ls

docker volume create <name>

docker volume rm <name>

docker volume inspect <name>

docker network ls

docker network create <name>

docker network inspect <name>

docker network connect <net> <container>

docker network disconnect <net> <container>

docker system prune -a

docker system prune -a --volumes

docker system df

docker system df -v

docker login

docker login <registry-url>

docker save -o image.tar <image>

docker load -i image.tar

docker events

docker version

docker info

curl -fsSL https://ollama.com/install.sh | sh

ollama run llama3

ollama pull mistral

ollama list

ollama rm <model>

ollama show llama3

ollama serve

ollama create mymodel -f Modelfile

ollama cp llama3 my-llama3

curl http://localhost:11434/api/generate -d '{"model":"llama3","prompt":"hello"}'

curl http://localhost:11434/api/chat -d '{"model":"llama3","messages":[{"role":"user","content":"hi"}]}'

ollama pull codellama

ollama run llama3 --system "You are helpful"

curl http://localhost:11434/api/embeddings -d '{"model":"llama3","prompt":"text"}'

pip install openai

export OPENAI_API_KEY='sk-...'

curl https://api.openai.com/v1/chat/completions -H 'Authorization: Bearer $OPENAI_API_KEY' -H 'Content-Type: application/json' -d '{"model":"gpt-4","messages":[{"role":"user","content":"hello"}]}'

curl https://api.openai.com/v1/models -H 'Authorization: Bearer $OPENAI_API_KEY'

curl https://api.openai.com/v1/embeddings -H 'Authorization: Bearer $OPENAI_API_KEY' -d '{"model":"text-embedding-3-small","input":"text"}'

curl https://api.openai.com/v1/images/generations -H 'Authorization: Bearer $OPENAI_API_KEY' -d '{"model":"dall-e-3","prompt":"a cat"}'

curl https://api.openai.com/v1/audio/speech -H 'Authorization: Bearer $OPENAI_API_KEY' -d '{"model":"tts-1","input":"Hello","voice":"alloy"}' --output speech.mp3

curl https://api.openai.com/v1/audio/transcriptions -H 'Authorization: Bearer $OPENAI_API_KEY' -F file=@audio.mp3 -F model=whisper-1

pip install anthropic

export ANTHROPIC_API_KEY='sk-ant-...'

curl https://api.anthropic.com/v1/messages -H 'x-api-key: $ANTHROPIC_API_KEY' -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' -d '{"model":"claude-sonnet-4-20250514","max_tokens":1024,"messages":[{"role":"user","content":"hello"}]}'

pip install huggingface_hub

huggingface-cli login

huggingface-cli download <model-id>

huggingface-cli upload <repo-id> <local-path>

huggingface-cli repo info <model-id>

huggingface-cli scan-cache

huggingface-cli delete-cache

huggingface-cli repo create <name> --type model

pip install torch torchvision torchaudio

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

pip install tensorflow

pip install transformers

pip install langchain langchain-openai

pip install llama-index

pip install llama-cpp-python

pip install vllm

pip install gradio

pip install streamlit

pip install litellm

pip install sentence-transformers

pip install faiss-cpu

pip install faiss-gpu

pip install chromadb

pip install pinecone-client

pip install weaviate-client

pip install qdrant-client

pip install spacy

python -m spacy download en_core_web_sm

pip install scikit-learn

pip install pandas

pip install matplotlib seaborn

pip install opencv-python

pip install Pillow

pip install datasets

pip install accelerate

pip install peft

pip install bitsandbytes

pip install trl

pip install unsloth

python -m vllm.entrypoints.openai.api_server --model <model>

python -m vllm.entrypoints.openai.api_server --model <model> --quantization awq

python app.py  # gradio interface

streamlit run app.py

litellm --model ollama/llama3 --port 8000

docker run --gpus all -p 8080:80 ghcr.io/huggingface/text-generation-inference --model-id <model>

cmake -B build && cmake --build build --config Release

cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release

./build/bin/llama-cli -m model.gguf -p 'Hello' -n 128

./build/bin/llama-quantize model.gguf model-q4.gguf Q4_K_M

./build/bin/llama-server -m model.gguf --port 8080

python convert_hf_to_gguf.py <model-dir>

nvcc --version

nvidia-smi

watch -n 1 nvidia-smi

python -c "import torch; print(torch.cuda.is_available())"

python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

python -m venv .venv && source .venv/bin/activate

conda create -n ml python=3.11 -y

conda activate ml

conda env list

conda install <package>

pip freeze > requirements.txt

pip install -r requirements.txt

uv pip install <package>

uv venv

jupyter notebook

jupyter lab

pip install jupyterlab notebook

wandb login

pip install wandb

mlflow ui --port 5000

pip install mlflow

tensorboard --logdir=./logs

pip install tensorboard

dvc init

dvc add data/

dvc push

pip install dvc

aws configure

aws configure --profile <name>

aws sts get-caller-identity

aws s3 ls

aws s3 ls s3://<bucket>/<prefix>/

aws s3 cp ./<file> s3://<bucket>/<key>

aws s3 sync ./dist s3://<bucket> --delete

aws s3 presign s3://<bucket>/<key> --expires-in 3600

aws s3 rm s3://<bucket>/<key>

aws cloudfront create-invalidation --distribution-id <id> --paths "/*"

aws ec2 describe-instances --query "Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress]" --output table

aws ec2 start-instances --instance-ids <id>

aws ec2 stop-instances --instance-ids <id>

aws lambda list-functions --query "Functions[].FunctionName"

aws lambda invoke --function-name <name> --payload '{}' out.json

aws logs tail /aws/lambda/<name> --follow

aws lambda update-function-code --function-name <name> --zip-file fileb://function.zip

aws ecr get-login-password --region <region> | docker login --username AWS --password-stdin <acct>.dkr.ecr.<region>.amazonaws.com

aws ecr create-repository --repository-name <name>

aws ecr list-images --repository-name <name>

aws cloudformation deploy --template-file template.yml --stack-name <name> --capabilities CAPABILITY_IAM

aws cloudformation delete-stack --stack-name <name>

aws ssm get-parameter --name <name> --with-decryption --query Parameter.Value --output text

aws secretsmanager get-secret-value --secret-id <id> --query SecretString --output text

gcloud auth login

gcloud config set project <project-id>

gcloud projects list

gcloud run deploy <service> --source . --region <region> --allow-unauthenticated

gcloud run services list

gcloud beta run services logs tail <service> --region <region>

gcloud builds submit --tag gcr.io/<project>/<image>

gsutil ls

gsutil cp ./<file> gs://<bucket>/

gsutil -m rsync -r ./dist gs://<bucket>

gcloud auth configure-docker

az login

az account set --subscription <id>

az group list --output table

az webapp up --name <app> --runtime "NODE:20-lts"

az webapp log tail --name <app> --resource-group <group>

az acr build --registry <registry> --image <image>:<tag> .

vercel

vercel --prod

vercel link

vercel env pull .env.local

vercel env add <NAME> production

vercel ls

vercel logs <deployment-url>

vercel rollback <deployment-url>

netlify deploy --prod --dir=dist

netlify dev

netlify link

netlify functions:log <name>

fly launch

fly deploy

fly logs

fly ssh console

fly scale count 2

fly secrets set <NAME>=<value>

wrangler deploy

wrangler dev

wrangler tail

wrangler secret put <NAME>

wrangler pages deploy ./dist

wrangler d1 execute <db> --command "SELECT 1"

wrangler r2 object put <bucket>/<key> --file ./<file>

heroku create <app>

git push heroku main

heroku logs --tail --app <app>

heroku config:set <NAME>=<value> --app <app>

heroku run bash --app <app>

railway up

curl -X POST "<render-deploy-hook-url>"

supabase start

supabase functions deploy <name>

scp -r ./dist <user>@<host>:/var/www/app

rsync -avz --delete ./dist/ <user>@<host>:/var/www/app/

ssh <user>@<host> 'cd /srv/app && ./deploy.sh'

kubectl config get-contexts

kubectl config use-context <context>

kubectl config set-context --current --namespace=<ns>

kubectl get pods

kubectl get pods -A -o wide

kubectl get pods -w

kubectl describe pod <pod>

kubectl logs <pod>

kubectl logs -f <pod> -c <container>

kubectl logs <pod> --previous

kubectl exec -it <pod> -- /bin/sh

kubectl port-forward pod/<pod> 8080:80

kubectl port-forward svc/<service> 8080:80

kubectl apply -f <file>.yaml

kubectl apply -f ./k8s/

kubectl delete -f <file>.yaml

kubectl rollout restart deployment/<name>

kubectl rollout status deployment/<name>

kubectl rollout undo deployment/<name>

kubectl rollout history deployment/<name>

kubectl scale deployment/<name> --replicas=3

kubectl autoscale deployment/<name> --min=2 --max=10 --cpu-percent=70

kubectl set image deployment/<name> <container>=<image>:<tag>

kubectl edit deployment/<name>

kubectl get deployment/<name> -o yaml

kubectl get events --sort-by=.lastTimestamp

kubectl top pods

kubectl top nodes

kubectl get nodes -o wide

kubectl drain <node> --ignore-daemonsets --delete-emptydir-data

kubectl cordon <node>

kubectl uncordon <node>

kubectl create secret generic <name> --from-literal=KEY=value

kubectl get secret <name> -o jsonpath="{.data.KEY}" | base64 -d

kubectl create configmap <name> --from-file=./config.yaml

kubectl cp <ns>/<pod>:/path/file ./file

kubectl run tmp --rm -it --image=busybox -- sh

kubectl debug -it <pod> --image=busybox --target=<container>

kubectl explain deployment.spec.template

kubectl apply -f <file>.yaml --dry-run=server

helm install <release> <chart>

helm upgrade --install <release> <chart> -f values.yaml

helm list -A

helm template <release> <chart> -f values.yaml

helm rollback <release> <revision>

helm uninstall <release>

helm repo add <name> <url> && helm repo update

kubectl kustomize ./overlays/prod

kubectl apply -k ./overlays/prod

minikube start

minikube dashboard

minikube image load <image>:<tag>

kind create cluster --name <name>

k9s

terraform init

terraform fmt -recursive

terraform validate

terraform plan -out=tfplan

terraform apply tfplan

terraform destroy

terraform state list

terraform import <address> <id>

terraform apply -target=<address>

terraform workspace select <name>

terraform output -raw <name>

ansible all -m ping -i inventory.ini

ansible-playbook -i inventory.ini site.yml

ansible-playbook -i inventory.ini site.yml --check --diff

ansible-galaxy install -r requirements.yml

ansible-vault encrypt group_vars/prod/vault.yml

packer build template.pkr.hcl

pulumi up

psql "postgresql://<user>:<pass>@<host>:5432/<db>"

psql -d <db> -f ./schema.sql

psql -d <db> -c "SELECT count(*) FROM users;"

\dt

\d+ <table>

\l

\x

pg_dump -Fc <db> > backup.dump

pg_dump --schema-only <db> > schema.sql

pg_restore -d <db> --clean --if-exists backup.dump

createdb <db>

dropdb <db>

SELECT pid, state, query FROM pg_stat_activity WHERE state <> 'idle';

SELECT pg_cancel_backend(<pid>);

SELECT relname, pg_size_pretty(pg_total_relation_size(relid)) FROM pg_catalog.pg_statio_user_tables ORDER BY pg_total_relation_size(relid) DESC;

EXPLAIN ANALYZE SELECT * FROM <table> WHERE <cond>;

VACUUM (ANALYZE, VERBOSE) <table>;

mysql -h <host> -u <user> -p <db>

mysqldump -u <user> -p <db> > backup.sql

mysql -u <user> -p <db> < backup.sql

SHOW TABLES;

DESCRIBE <table>;

SHOW FULL PROCESSLIST;

mongosh "mongodb://<host>:27017/<db>"

show collections

db.<collection>.find({ <field>: <value> }).limit(10)

db.<collection>.countDocuments({})

db.<collection>.createIndex({ <field>: 1 })

mongodump --uri="mongodb://<host>/<db>" --out=./dump

mongorestore --uri="mongodb://<host>" ./dump

redis-cli -h <host> -p 6379

redis-cli DBSIZE

redis-cli --scan --pattern '<prefix>*'

redis-cli TTL <key>

redis-cli MONITOR

redis-cli FLUSHDB

sqlite3 <file>.db

.tables

.schema <table>

sqlite3 <file>.db .dump > dump.sql

sqlite3 -header -csv <file>.db "SELECT * FROM <table>;" > out.csv

npx prisma generate

npx prisma migrate dev --name <name>

npx prisma migrate deploy

npx prisma migrate reset

npx prisma db push

npx prisma studio

npx drizzle-kit generate

npx drizzle-kit push

npx drizzle-kit studio