DEV Community: Lucas M Dev

Test Article

Lucas M Dev — Sun, 29 Mar 2026 17:52:16 +0000

Test content

10 Coding Mistakes That Cost Me $10K+ (2026)

Lucas M Dev — Sun, 29 Mar 2026 17:52:14 +0000

10 Mistakes

No backups - Lost 3 days of work
No tests - Bugs in production
Weak passwords - $2K AWS bill

Read full article

GitHub Actions CI/CD for Beginners: Deploy Your App Automatically in 2026

Lucas M Dev — Sun, 29 Mar 2026 16:31:49 +0000

You push code, tests run automatically, and your app deploys itself. That's CI/CD, and GitHub Actions makes it free and surprisingly easy.

What Is CI/CD?

CI (Continuous Integration): Automatically run tests when you push code
CD (Continuous Deployment): Automatically deploy when tests pass

GitHub Actions gives you 2,000 free minutes/month on public repos (and 500 on private).

Your First Workflow: Run Tests on Every Push

Create .github/workflows/test.yml:

name: Run Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

      - name: Run linter
        run: npm run lint

That's it. Push this file and GitHub will run your tests on every push and PR.

Deploy to Vercel on Merge

name: Deploy to Vercel

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Vercel
        uses: amondnet/vercel-action@v25
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
          vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
          vercel-args: '--prod'

Deploy a Docker App to Railway

name: Deploy to Railway

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test

  deploy:
    needs: test  # Only deploy if tests pass
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Railway CLI
        run: npm install -g @railway/cli

      - name: Deploy
        run: railway up
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}

Useful Workflow Patterns

Matrix Testing (Multiple Node Versions)

strategy:
  matrix:
    node-version: [18, 20, 22]

steps:
  - uses: actions/setup-node@v4
    with:
      node-version: ${{ matrix.node-version }}

Cache Dependencies

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}

Run Only When Specific Files Change

on:
  push:
    paths:
      - 'src/**'
      - 'package.json'

Scheduled Workflows (Cron)

on:
  schedule:
    - cron: '0 9 * * 1'  # Every Monday at 9 AM UTC

Setting Up Secrets

Go to your repo > Settings > Secrets and variables > Actions
Click "New repository secret"
Add your secret (e.g., VERCEL_TOKEN)

Never put secrets directly in workflow files.

Common Mistakes

Not using npm ci — Use npm ci instead of npm install in CI (it's faster and more deterministic)
Forgetting to cache — Caching node_modules or ~/.npm saves 30-60 seconds per run
Running everything on push — Use path filters to avoid running tests when you only changed docs
Not setting timeout — Add timeout-minutes: 10 to prevent stuck workflows from eating your minutes

My Recommended Starter Setup

For most projects, you need just two workflows:

test.yml — Runs on every push/PR: lint + test
deploy.yml — Runs on push to main (after tests pass): deploy to production

Start simple, add complexity only when you need it.

More developer guides at lucasmdevdev.github.io

Stop Hardcoding Secrets: Environment Variables Best Practices in 2026

Lucas M Dev — Sun, 29 Mar 2026 16:31:43 +0000

I've reviewed hundreds of GitHub repos. The #1 security mistake? Hardcoded secrets. Here's how to handle environment variables properly in 2026.

The Problem

// DO NOT DO THIS
const db = mysql.connect({
  host: 'production-db.example.com',
  password: 'super_secret_password_123'
});

This code gets committed, pushed, and now your database password is public forever (yes, even if you delete the commit — git history remembers).

The Solution: .env Files + Environment Variables

Step 1: Create a .env file

DATABASE_URL=postgres://user:pass@host:5432/mydb
API_KEY=sk_live_abc123
JWT_SECRET=your-256-bit-secret
NODE_ENV=development

Step 2: Load it in your code

Node.js:

npm install dotenv

require('dotenv').config();

const db = mysql.connect({
  host: process.env.DATABASE_HOST,
  password: process.env.DATABASE_PASSWORD
});

Python:

pip install python-dotenv

from dotenv import load_dotenv
import os

load_dotenv()

db_password = os.getenv('DATABASE_PASSWORD')

Step 3: NEVER commit .env

Add to .gitignore:

.env
.env.local
.env.production

Best Practices Checklist

1. Use .env.example (committed) + .env (gitignored)

# .env.example (committed — shows structure, no real values)
DATABASE_URL=postgres://user:password@localhost:5432/mydb
API_KEY=your-api-key-here
JWT_SECRET=generate-a-random-string

2. Validate env vars at startup

const required = ['DATABASE_URL', 'API_KEY', 'JWT_SECRET'];

for (const key of required) {
  if (!process.env[key]) {
    console.error(`Missing required env var: ${key}`);
    process.exit(1);
  }
}

3. Use different .env files per environment

.env.development
.env.staging
.env.production

4. Never log environment variables

// NEVER do this
console.log('Config:', process.env);

// If you must debug, redact:
console.log('DB connected to:', process.env.DATABASE_HOST);

5. Rotate secrets regularly

Set a calendar reminder. Rotate API keys and passwords at least every 90 days.

Production: Use a Secrets Manager

For production, .env files aren't enough. Use:

Service	Free Tier	Best For
Doppler	5 projects	Small teams
AWS Secrets Manager	30-day trial	AWS deployments
Infisical	Unlimited (open source)	Self-hosted
Railway/Vercel env	Built-in	PaaS deployments

Quick Audit: Is Your Repo Safe?

Run this in your repo:

# Check if .env is in .gitignore
grep -q ".env" .gitignore && echo "OK: .env is gitignored" || echo "WARNING: .env not in .gitignore"

# Check for hardcoded secrets (basic scan)
grep -rn "password\s*=\s*['\"]" --include="*.js" --include="*.py" --include="*.ts" .
grep -rn "api.key\s*=\s*['\"]" --include="*.js" --include="*.py" --include="*.ts" .

TL;DR

Secrets go in .env, never in code
.env goes in .gitignore, always
.env.example gets committed (with placeholder values)
Validate env vars at startup
Use a secrets manager in production

More developer guides at lucasmdevdev.github.io

How to Implement API Rate Limiting in Node.js (3 Methods Compared)

Lucas M Dev — Sun, 29 Mar 2026 16:26:16 +0000

Rate limiting is one of those things every API needs but most tutorials overcomplicate. Here are 3 practical approaches, from simplest to most robust.

Why Rate Limiting Matters

Without it, a single user (or bot) can:

Crash your server with too many requests
Scrape your entire database
Run up your cloud bill overnight

Method 1: express-rate-limit (Quick & Easy)

npm install express-rate-limit

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per window
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: 'Too many requests, please try again later.' }
});

app.use('/api/', limiter);

Pros: 5 lines of code, works immediately
Cons: In-memory only — resets on server restart, doesn't work across multiple instances

Method 2: Redis-based Rate Limiting (Production Ready)

npm install rate-limit-redis ioredis

const RedisStore = require('rate-limit-redis');
const Redis = require('ioredis');

const redis = new Redis(process.env.REDIS_URL);

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  store: new RedisStore({
    sendCommand: (...args) => redis.call(...args),
  }),
});

Pros: Persists across restarts, works with multiple server instances
Cons: Requires Redis

Method 3: Sliding Window with Custom Logic

For more control, build your own:

const requestCounts = new Map();

function slidingWindowLimiter(maxRequests, windowMs) {
  return (req, res, next) => {
    const key = req.ip;
    const now = Date.now();

    if (!requestCounts.has(key)) {
      requestCounts.set(key, []);
    }

    const timestamps = requestCounts.get(key)
      .filter(t => t > now - windowMs);

    if (timestamps.length >= maxRequests) {
      return res.status(429).json({
        error: 'Rate limit exceeded',
        retryAfter: Math.ceil((timestamps[0] + windowMs - now) / 1000)
      });
    }

    timestamps.push(now);
    requestCounts.set(key, timestamps);
    next();
  };
}

// 50 requests per minute
app.use('/api/', slidingWindowLimiter(50, 60 * 1000));

Which Method Should You Use?

Scenario	Recommended Method
Side project / MVP	Method 1 (express-rate-limit)
Production API	Method 2 (Redis)
Custom billing/quotas	Method 3 (Sliding window)

Bonus: Per-User Rate Limiting

Instead of limiting by IP, limit by API key:

const limiter = rateLimit({
  windowMs: 60 * 1000,
  max: 30,
  keyGenerator: (req) => req.headers['x-api-key'] || req.ip,
});

Key Takeaways

Always add rate limiting — even a basic one is better than none
Return proper 429 status codes and Retry-After headers
Use Redis in production for consistency across instances
Consider different limits for different endpoints (auth vs data)

More developer guides at lucasmdevdev.github.io

Comment créer une newsletter rentable en 2026 (guide complet)

Lucas M Dev — Sun, 29 Mar 2026 16:25:01 +0000

La newsletter est redevenue l'un des meilleurs canaux de monétisation en ligne. Pas besoin d'algorithme, pas de reach organique à supplier — vos abonnés reçoivent vos emails directement. Voici comment créer la vôtre de zéro et la rendre rentable.

Pourquoi la newsletter en 2026 ?

Propriété totale : contrairement aux réseaux sociaux, votre liste vous appartient
Taux d'engagement élevé : 20-40% d'open rate vs 2-5% sur les réseaux
Multiples sources de revenus : sponsoring, abonnements, affiliation, produits
Coût de démarrage proche de zéro : outils gratuits jusqu'à 1000 abonnés

Choisir son outil : Beehiiv vs Substack vs Brevo

	Beehiiv	Substack	Brevo
Plan gratuit	2500 abonnés	Illimité	300 emails/jour
Commission	0%	10%	0%
Personnalisation	Excellent	Moyen	Bon
SEO web	Blog intégré	Natif	Basique
Analytics	Excellent	Basique	Bon

Mon choix en 2026 : Beehiiv. La plateforme a explosé en 2024-2025 et est maintenant la référence pour les créateurs sérieux. Plan gratuit jusqu'à 2500 abonnés, zéro commission, et un réseau de sponsoring intégré.

Trouver sa niche

La clé du succès d'une newsletter : être spécifique. Voici les niches les plus rentables en 2026 :

IA & automatisation : outils, tutoriels, cas d'usage
Finance personnelle : investissement, budget, side hustles
Tech pour entrepreneurs : outils, productivité, no-code
Santé & bien-être : nutrition, fitness, mindfulness
Carrière & freelance : CV, négociation, remote work

Faire croître sa liste

Stratégies gratuites

Contenu gratuit sur LinkedIn/X : postez des extraits, le lien newsletter en bio
Cross-promotions : échangez des mentions avec d'autres newsletters de votre niche
Lead magnet : offrez un guide/template/outil en échange de l'inscription
SEO blog : articles qui ranquent sur Google, call-to-action newsletter en bas
Reddit/forums : participez aux communautés, mentionnez votre newsletter quand pertinent

Stratégies payantes (quand vous avez du revenus)

Sponsoring croisé : payez d'autres newsletters pour vous mentionner (Sparkloop)
Publicité X/LinkedIn : ciblage très précis

Monétiser sa newsletter

1. Sponsoring (le plus rentable)

Vendez des emplacements publicitaires dans vos emails. Tarif typique : 20-50€ CPM (pour 1000 lecteurs). Avec 5000 abonnés actifs, vous pouvez facturer 100-250€ par email.

2. Abonnement payant

Un tier premium à 5-10€/mois avec du contenu exclusif. Même 100 abonnés payants = 500-1000€/mois.

3. Affiliation

Recommandez des outils que vous utilisez vraiment. Intégrez vos liens affiliés naturellement dans votre contenu.

4. Vendre vos propres produits

Template, formation, consulting. La newsletter est le meilleur canal de vente quand votre audience vous fait confiance.

Le plan d'action — 90 jours

Semaine 1 : Créer le compte Beehiiv, choisir la niche, rédiger les 3 premiers emails
Semaine 2-4 : Publier régulièrement (1x/semaine), promouvoir sur LinkedIn/X
Mois 2 : Créer un lead magnet, mettre en place des cross-promotions
Mois 3 : Approcher les premiers sponsors si >500 abonnés, ou lancer un tier payant

Retrouvez plus de guides sur lucasmdevdev.github.io

How to Deploy Your App for Free in 2026 (Complete Stack)

Lucas M Dev — Sat, 28 Mar 2026 22:38:45 +0000

You don't need to pay for hosting. In 2026, there are excellent free options for almost every type of project.

Here's what to use and when.

Static Sites (HTML, React, Vue, etc.)

Vercel — Best for frontend

Free tier: 100GB bandwidth, unlimited projects, automatic SSL.

npm install -g vercel
vercel deploy

That's it. Your site is live.

Bonus: Git integration. Every push to main automatically deploys.

Netlify — Great alternative

Free tier: 100GB bandwidth, 300 build minutes/month.

npm install -g netlify-cli
netlify deploy --dir=dist --prod

GitHub Pages — For static files

Free tier: Unlimited for public repos.

# In your repo settings → Pages → Source: main branch
# Done. Your site is at username.github.io/repo-name

Best for: Documentation, portfolio, DevToolkit-style projects.

Backend (Node.js, Python, etc.)

Railway — Best for side projects

Free tier: $5 credit/month (usually enough for a small app).

npm install -g @railway/cli
railway login
railway init
railway up

Railway auto-detects your stack (Node, Python, Go, etc.) and deploys it.

Render — Free for small apps

Free tier: 1 web service, sleeps after 15 minutes of inactivity.

# render.yaml
services:
  - type: web
    name: my-app
    env: node
    buildCommand: npm install
    startCommand: node server.js

Gotcha: The free tier has cold starts (~30 seconds). Use paid ($7/month) for production.

Fly.io — For containers

Free tier: 3 shared-cpu VMs, 256MB RAM each.

fly launch
fly deploy

Excellent for Docker-based apps. Also great for running databases.

Databases

Supabase — Postgres + Auth + Storage

Free tier: 500MB storage, 50k auth users, 2GB file storage.

import { createClient } from '@supabase/supabase-js'
const supabase = createClient(url, key)

// Query
const { data } = await supabase.from('users').select('*')

// Insert
await supabase.from('users').insert({ name: 'John', email: 'john@example.com' })

The Supabase free tier is genuinely generous.

PlanetScale — MySQL

Free hobby tier: 5GB storage, 1 billion row reads/month.

Turso — SQLite at the edge

Free tier: 500 databases, 9GB storage.

turso db create myapp
turso db shell myapp

Serverless Functions

Vercel Edge Functions

// api/hello.js
export default function handler(req, res) {
  res.json({ message: 'Hello World' });
}

Deploy with vercel. Your function is at your-domain.vercel.app/api/hello.

Cloudflare Workers

Free tier: 100,000 requests/day.

export default {
  async fetch(request) {
    return new Response('Hello World!');
  }
};

Fastest cold starts in the industry (0ms — they don't cold start at all).

The Free Stack I'd Use in 2026

For a full-stack app:

Component	Service	Cost
Frontend	Vercel	Free
Backend	Railway	Free ($5 credit)
Database	Supabase	Free
Auth	Supabase Auth	Free
File storage	Supabase Storage	Free
CDN	Cloudflare	Free
Domain	Freenom or .github.io	Free
Monitoring	UptimeRobot	Free

Total monthly cost: $0

You can build and launch a real product with this stack. DevToolkit runs entirely on GitHub Pages — free forever.

When to pay

Switch to paid when:

You need custom domains with SSL on multiple services
Your app has consistent traffic (free tiers have limits)
You need more storage/compute
You need SLAs and uptime guarantees

Until then: stay free.

What's your go-to free hosting stack? Drop it in the comments.

React Hooks Explained: A Visual Guide for 2026

Lucas M Dev — Sat, 28 Mar 2026 22:35:29 +0000

React Hooks can be confusing when you're new to them. This guide explains the most important ones with clear examples.

useState — Local component state

import { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <button onClick={() => setCount(count + 1)}>
      Clicked {count} times
    </button>
  );
}

When to use: Anything the component needs to remember between renders — form values, toggles, counters.

Gotcha: State updates are asynchronous.

// ❌ This won't work as expected
setCount(count + 1);
setCount(count + 1); // Both use the same `count` value

// ✅ Use the updater function instead
setCount(prev => prev + 1);
setCount(prev => prev + 1); // Now it's +2

useEffect — Side effects

import { useEffect, useState } from 'react';

function UserProfile({ userId }) {
  const [user, setUser] = useState(null);

  useEffect(() => {
    // Runs after every render where userId changes
    fetch(`/api/users/${userId}`)
      .then(r => r.json())
      .then(setUser);
  }, [userId]); // dependency array

  return <div>{user?.name}</div>;
}

The dependency array:

[] — Run once on mount
[value] — Run when value changes
No array — Run after every render (usually wrong!)

Always clean up subscriptions:

useEffect(() => {
  const subscription = subscribe(userId);

  return () => {
    subscription.unsubscribe(); // cleanup!
  };
}, [userId]);

useContext — Share state without prop drilling

// 1. Create the context
const ThemeContext = createContext('light');

// 2. Provide it at the top
function App() {
  const [theme, setTheme] = useState('dark');
  return (
    <ThemeContext.Provider value={{ theme, setTheme }}>
      <Page />
    </ThemeContext.Provider>
  );
}

// 3. Use it anywhere in the tree
function Button() {
  const { theme } = useContext(ThemeContext);
  return <button className={theme}>Click me</button>;
}

useRef — DOM references and mutable values

function TextInput() {
  const inputRef = useRef(null);

  const focusInput = () => {
    inputRef.current.focus();
  };

  return (
    <>
      <input ref={inputRef} />
      <button onClick={focusInput}>Focus</button>
    </>
  );
}

Also useful for: storing values that shouldn't trigger re-renders.

const renderCount = useRef(0);
renderCount.current += 1; // Doesn't cause re-render

useMemo — Expensive calculations

function ProductList({ products, minPrice }) {
  // This only recalculates when products or minPrice changes
  const filtered = useMemo(() => {
    return products.filter(p => p.price >= minPrice);
  }, [products, minPrice]);

  return <ul>{filtered.map(p => <li key={p.id}>{p.name}</li>)}</ul>;
}

Don't overuse this. Only use it when:

The calculation is genuinely expensive
You've measured it's causing performance issues

useCallback — Stable function references

function Parent({ id }) {
  // Without useCallback, a new function is created every render
  const handleClick = useCallback(() => {
    doSomethingWith(id);
  }, [id]);

  return <ExpensiveChild onClick={handleClick} />;
}

When to use: When passing callbacks to React.memo wrapped children.

useReducer — Complex state logic

const initialState = { count: 0, error: null, loading: false };

function reducer(state, action) {
  switch (action.type) {
    case 'increment': return { ...state, count: state.count + 1 };
    case 'decrement': return { ...state, count: state.count - 1 };
    case 'reset': return initialState;
    default: return state;
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <div>
      Count: {state.count}
      <button onClick={() => dispatch({ type: 'increment' })}>+</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
    </div>
  );
}

Use instead of useState when: multiple pieces of state are related and change together.

Custom Hooks — Reuse logic

The real power of hooks is composability. Extract logic into custom hooks:

// Custom hook for API calls
function useApi(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    setLoading(true);
    fetch(url)
      .then(r => {
        if (!r.ok) throw new Error(`HTTP ${r.status}`);
        return r.json();
      })
      .then(data => { setData(data); setLoading(false); })
      .catch(err => { setError(err.message); setLoading(false); });
  }, [url]);

  return { data, loading, error };
}

// Use it
function UserList() {
  const { data, loading, error } = useApi('/api/users');

  if (loading) return <Spinner />;
  if (error) return <Error message={error} />;
  return <ul>{data.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
}

Quick reference

Hook	Purpose
`useState`	Local state
`useEffect`	Side effects, data fetching
`useContext`	Share state without props
`useRef`	DOM refs, mutable values
`useMemo`	Memoize expensive calcs
`useCallback`	Stable callback references
`useReducer`	Complex state logic

Building something with React? DevToolkit has free tools like a JSON formatter, UUID generator, and more — no signup needed.

The VS Code Extensions I Actually Use Every Day in 2026

Lucas M Dev — Sat, 28 Mar 2026 22:33:45 +0000

I've been using VS Code as my main editor for 5+ years. In that time, I've installed (and uninstalled) hundreds of extensions.

Here are the ones that actually stuck — extensions I use in every project.

Productivity Boosters

1. GitLens — Git supercharged

Why it's essential: See who wrote every line, when, and why — without leaving your editor.

GitLens shows inline blame annotations, a git history sidebar, and lets you compare branches, commits, and more. The free tier is incredibly powerful.

Install: eamodio.gitlens

My favorite feature: Hovering over a line to see the full commit message and diff.

2. GitHub Copilot (or Codeium for free)

I use Codeium instead of Copilot because it's free and surprisingly good.

Suggests entire functions based on context
Completes repetitive patterns automatically
Works with 70+ languages

Copilot: GitHub.copilot
Codeium (free): Codeium.codeium

3. Prettier — Code formatter

Stop arguing about formatting. Prettier handles it automatically.

// .vscode/settings.json
{
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true
}

Install: esbenp.prettier-vscode

4. ESLint

Catch bugs before they happen. Works with React, Vue, Node.js, TypeScript.

Install: dbaeumer.vscode-eslint

5. Error Lens — Inline errors

Makes errors and warnings impossible to miss by showing them inline on the problematic line.

Before Error Lens: squiggly underlines you might miss.
After Error Lens: bright red text right where the problem is.

Install: usernamehw.errorlens

Language-Specific

6. Tailwind CSS IntelliSense

If you use Tailwind, this is not optional. Autocomplete for every class, hover to see the generated CSS.

Install: bradlc.vscode-tailwindcss

7. Prisma

Official extension for Prisma schema files. Syntax highlighting, formatting, autocompletion for models and fields.

Install: Prisma.prisma

8. Docker

Manage containers, images, and docker-compose from VS Code. View logs, run commands, inspect containers — all without a terminal.

Install: ms-azuretools.vscode-docker

Navigation & Search

9. Auto Rename Tag

Rename an HTML/JSX tag and the closing tag updates automatically. Sounds small. Saves a surprising amount of time.

Install: formulahendry.auto-rename-tag

10. Path IntelliSense

Autocomplete for file paths in import statements. No more typos in ../../components/Button.

Install: christian-kohler.path-intellisense

11. Todo Tree

Scans your project for TODO, FIXME, HACK comments and shows them in a tree view. Great for not forgetting things mid-feature.

Install: gruntfuggly.todo-tree

Visual Improvements

12. One Dark Pro (theme)

The most downloaded VS Code theme. Clean, easy on the eyes, works well with every language.

Install: zhuangtongfa.material-theme

13. Material Icon Theme (icons)

Replace the default file icons with colorful, recognizable icons for every file type.

Install: PKief.material-icon-theme

14. Bracket Pair Colorizer 2 (built-in in VS Code now)

Actually, VS Code now has bracket pair colorization built in. Enable it in settings:

{
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": true
}

Remote & Advanced

15. Remote - SSH

Work on remote servers as if they're local. Edit files, run terminals, debug — all through SSH. Game-changing for cloud development.

Install: ms-vscode-remote.remote-ssh

16. REST Client

Send HTTP requests directly from VS Code. Write your requests in .http files, see responses inline.

GET https://api.example.com/users HTTP/1.1
Content-Type: application/json

###

POST https://api.example.com/users HTTP/1.1
Content-Type: application/json

{
  "name": "Test User",
  "email": "test@example.com"
}

Much better than switching to Postman for quick tests.

Install: humao.rest-client

My VS Code settings worth sharing

{
  "editor.fontSize": 14,
  "editor.lineHeight": 1.6,
  "editor.fontFamily": "JetBrains Mono, Fira Code, monospace",
  "editor.fontLigatures": true,
  "editor.tabSize": 2,
  "editor.formatOnSave": true,
  "editor.minimap.enabled": false,
  "editor.wordWrap": "on",
  "editor.cursorBlinking": "smooth",
  "editor.smoothScrolling": true,
  "editor.bracketPairColorization.enabled": true,
  "workbench.colorTheme": "One Dark Pro",
  "workbench.iconTheme": "material-icon-theme",
  "terminal.integrated.fontSize": 13,
  "files.autoSave": "onFocusChange",
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

The ones I deliberately left out

Emmet — Built into VS Code, no extension needed.

IntelliCode — It's fine, but Copilot/Codeium is better.

Color Highlight — CSS variables in frameworks make this less useful now.

Quick tool tip

If you're formatting code or converting between case styles, I built DevToolkit — 31 free browser tools for developers including a Text Case Converter, JSON Formatter, and more. No signup required.

What extensions am I missing? Drop them in the comments.

The 15 Terminal Commands I Use Every Day (And How They Actually Work)

Lucas M Dev — Sat, 28 Mar 2026 22:28:49 +0000

I've been using Linux for years. These 15 commands are in my muscle memory — I use all of them daily.

Not just the commands, but how and why they work, so you can adapt them.

1. `grep` with context

# Just match
grep "error" app.log

# With 3 lines before and after (gives context)
grep -C 3 "error" app.log

# Recursive in directory
grep -r "TODO" ./src

# Count matches per file
grep -rc "console.log" ./src

# Case insensitive + show line numbers
grep -in "warning" app.log

Why it matters: Finding errors in logs without context is useless. -C 3 changes everything.

2. `find` with actions

# Find and delete old files
find /tmp -type f -mtime +7 -delete

# Find and execute a command
find . -name "*.log" -exec gzip {} \;

# Find by size
find . -type f -size +100M

# Find by permissions
find . -type f -perm 777

3. `awk` for quick data extraction

# Print second column
awk '{print $2}' file.txt

# Sum a column
awk '{sum += $3} END {print sum}' data.csv

# Print lines where column 2 > 100
awk '$2 > 100' data.csv

# Process CSV
awk -F',' '{print $1, $3}' data.csv

4. `sed` for quick edits

# Replace in file (in-place)
sed -i 's/localhost/production.server.com/g' config.txt

# Delete lines matching pattern
sed -i '/^#/d' config.txt

# Print specific lines
sed -n '10,20p' large-file.txt

5. `tmux` for persistent sessions

# New named session
tmux new -s work

# Detach (keep running)
Ctrl+B, then D

# List sessions
tmux ls

# Reattach
tmux attach -t work

# Split pane horizontally
Ctrl+B, then "

# Split pane vertically
Ctrl+B, then %

Why it matters: SSH drops? Your work is still running. tmux is essential for remote servers.

6. `rsync` for safe file sync

# Sync local to remote (dry run first!)
rsync -avzn ~/projects/ user@server:/backup/

# Actually sync
rsync -avz --delete ~/projects/ user@server:/backup/

# Sync with progress
rsync -avz --progress ~/big-folder/ /backup/

7. `watch` for monitoring

# Run a command every 2 seconds
watch -n 2 'df -h'

# Watch for changes
watch -d 'ls -la /tmp'

# Monitor disk usage
watch -n 5 'du -sh /var/log/*'

8. `jq` for JSON processing

# Pretty print
curl -s api.example.com/data | jq .

# Extract field
curl -s api.example.com/users | jq '.[].name'

# Filter array
curl -s api.example.com/users | jq '.[] | select(.active == true)'

# Transform
curl -s api.example.com/users | jq '[.[] | {id, name}]'

9. Process substitution

# Compare outputs without temp files
diff <(sort file1.txt) <(sort file2.txt)

# Pass command output as file to another command
wc -l <(grep "error" app.log)

10. `xargs` for bulk operations

# Kill processes by name
pgrep node | xargs kill

# Delete files from a list
cat files-to-delete.txt | xargs rm

# Run command for each line in parallel
cat urls.txt | xargs -P 4 -I {} curl -O {}

11. Brace expansion

# Create multiple files at once
touch test{1,2,3,4,5}.txt

# Create nested directories
mkdir -p project/{src,tests,docs}/{components,utils}

# Backup a file
cp config.json{,.bak}

12. `!!` and `!$`

# Repeat last command with sudo
sudo !!

# Use last argument of previous command
ls /var/log/
cat !$  # cat /var/log/

13. Process management

# Run in background
command &

# Bring back to foreground
fg

# List background jobs
jobs

# Run immune to hangup (survives SSH disconnect)
nohup command &

# Check what's using a port
lsof -i :8080

14. History tricks

# Search history
history | grep docker

# Ctrl+R interactive search
# Type partial command, keep pressing Ctrl+R to cycle

# Run specific history number
!42

# Print last N commands
history 10

15. `curl` for API testing

# GET with timing
curl -w "\nTime: %{time_total}s" https://api.example.com/health

# POST JSON
curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}' \
  https://api.example.com/data

# Save response
curl -o response.json https://api.example.com/data

# Follow redirects + show headers
curl -Li https://example.com

Cheat sheet bookmark

I built a one-page terminal cheat sheet with these commands. Check DevToolkit for 31 browser tools including a regex tester and diff viewer.

What command am I missing from your daily workflow? Drop it in the comments.

Python Automation Scripts That Will Save You 5+ Hours Per Week

Lucas M Dev — Sat, 28 Mar 2026 22:23:47 +0000

If you're writing the same repetitive tasks every week, you're losing hours that Python could give back.

Here are 8 Python automation scripts I use regularly — complete, copy-paste ready.

1. Rename files in bulk

import os
from pathlib import Path

def bulk_rename(folder, old_ext, new_ext):
    folder = Path(folder)
    for file in folder.glob(f"*.{old_ext}"):
        file.rename(file.with_suffix(f".{new_ext}"))
        print(f"Renamed: {file.name}")

# Example: rename all .jpeg to .jpg
bulk_rename("./images", "jpeg", "jpg")

Time saved: 20 minutes per rename session.

2. Send yourself a daily summary email

import smtplib
from email.mime.text import MIMEText
from datetime import datetime

def send_summary(sender, password, recipient, subject, body):
    msg = MIMEText(body)
    msg["Subject"] = subject
    msg["From"] = sender
    msg["To"] = recipient

    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
        server.login(sender, password)
        server.sendmail(sender, recipient, msg.as_string())

# In your cron job:
send_summary(
    "you@gmail.com", "your-app-password",
    "you@gmail.com",
    f"Daily Summary {datetime.now().strftime('%Y-%m-%d')}",
    "Tasks done: ..."
)

3. Monitor a website and alert when it's down

import requests
import time
import smtplib
from datetime import datetime

def check_site(url, check_every=60):
    while True:
        try:
            response = requests.get(url, timeout=10)
            if response.status_code != 200:
                print(f"⚠️ {url} returned {response.status_code}")
        except requests.RequestException as e:
            print(f"❌ {url} is DOWN: {e}")
            # Send alert email here
        time.sleep(check_every)

check_site("https://your-website.com")

4. Organize downloads folder automatically

import shutil
from pathlib import Path

RULES = {
    "Images": [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"],
    "Documents": [".pdf", ".docx", ".xlsx", ".pptx", ".txt"],
    "Videos": [".mp4", ".mkv", ".avi", ".mov"],
    "Audio": [".mp3", ".wav", ".flac", ".ogg"],
    "Code": [".py", ".js", ".html", ".css", ".json", ".zip"],
}

def organize_downloads():
    downloads = Path.home() / "Downloads"
    for file in downloads.iterdir():
        if file.is_file():
            for folder, extensions in RULES.items():
                if file.suffix.lower() in extensions:
                    dest = downloads / folder
                    dest.mkdir(exist_ok=True)
                    shutil.move(str(file), str(dest / file.name))
                    print(f"Moved {file.name} → {folder}/")
                    break

organize_downloads()

Run this in a cron job every day. Your Downloads folder will never be a disaster again.

5. Convert CSV to clean JSON

import csv
import json
from pathlib import Path

def csv_to_json(csv_file, json_file=None):
    path = Path(csv_file)
    if not json_file:
        json_file = path.with_suffix(".json")

    with open(path, newline="", encoding="utf-8") as f:
        data = list(csv.DictReader(f))

    with open(json_file, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

    print(f"Converted: {len(data)} rows → {json_file}")
    return data

csv_to_json("data.csv")

6. Screenshot a webpage automatically

from playwright.sync_api import sync_playwright

def screenshot_url(url, output="screenshot.png", width=1280, height=720):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page(viewport={"width": width, "height": height})
        page.goto(url, wait_until="networkidle")
        page.screenshot(path=output, full_page=True)
        browser.close()
    print(f"Screenshot saved: {output}")

screenshot_url("https://github.com", "github.png")

7. Find duplicate files

import hashlib
from pathlib import Path
from collections import defaultdict

def find_duplicates(folder):
    hashes = defaultdict(list)
    for file in Path(folder).rglob("*"):
        if file.is_file():
            h = hashlib.md5(file.read_bytes()).hexdigest()
            hashes[h].append(file)

    duplicates = {h: files for h, files in hashes.items() if len(files) > 1}
    for h, files in duplicates.items():
        print(f"Duplicate group ({h[:8]}):")
        for f in files:
            print(f"  {f}")

    return duplicates

find_duplicates("./my-folder")

8. Generate a daily report from your git repos

import subprocess
from datetime import datetime, timedelta

def git_report(repo_path, days=1):
    since = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
    result = subprocess.run(
        ["git", "log", f"--since={since}", "--oneline", "--all", "--author=you"],
        cwd=repo_path,
        capture_output=True, text=True
    )
    commits = result.stdout.strip().split("\n")
    commits = [c for c in commits if c]
    print(f"\n📦 {repo_path}")
    print(f"   {len(commits)} commits since {since}")
    for c in commits:
        print(f"   → {c}")

for repo in ["/path/to/repo1", "/path/to/repo2"]:
    git_report(repo)

Automate everything

These scripts are just the beginning. The rule I follow: if I do something more than 3 times, I automate it.

Want more Python automation examples? Follow me on Dev.to — I post new scripts regularly.

And if you need a quick JSON/CSV converter, Base64 encoder, or similar without writing code: DevToolkit has 31 free tools.

DevToolkit Update: 31 Free Developer Tools + New CSS Generator, Meta Tag Builder, and More

Lucas M Dev — Sat, 28 Mar 2026 22:21:58 +0000

I just pushed a major update to DevToolkit: 31 free browser-based developer tools (up from 22).

What's new in this update

I added 6 new tools that I kept missing:

🔤 Text Case Converter

Convert text between camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE, dot.case and more. All 12 cases at once, with one-click copy.

→ Try Text Case Converter

📊 Word & Character Counter

Count words, characters, sentences, paragraphs. Get reading time estimate (200 wpm) and speaking time (130 wpm). See the top 10 most frequent words.

Useful when you're writing blog posts, documentation, or anything with a target length.

→ Try Word Counter

📐 PX ↔ REM Converter

Convert between pixels and REM units with a custom base font size. Includes a reference table for common values (8px → 128px).

No more mental math when writing responsive CSS.

→ Try PX-REM Converter

🌑 CSS Box Shadow Generator

Visual generator for box-shadow CSS. Adjust offset X/Y, blur, spread, color, opacity, and inset — see the live preview update in real time. Comes with 6 presets (small, medium, large, glow, inset).

→ Try Box Shadow Generator

🏷️ Meta Tag Generator

Generate SEO, Open Graph, and Twitter Card meta tags for any webpage. Includes:

Character counter for title (60) and description (160)
Google preview rendering
One-click copy of all generated tags

→ Try Meta Tag Generator

🖼️ Image to Base64

Drop an image → get the Base64 output in multiple formats: Data URL, raw Base64, CSS background-image, or HTML <img> tag.

Everything runs locally — your image never gets uploaded anywhere. Supports PNG, JPG, GIF, WebP, SVG up to 5MB.

→ Try Image to Base64

The full list: 31 tools

DevToolkit now covers:

Formatters: JSON, CSS, SQL, Markdown Preview

Encoders: Base64, URL, HTML, JWT, Image to Base64

Converters: Timestamp, Color, Number Base, CSV↔JSON, JSON→TypeScript, Text Case, PX↔REM

Generators: UUID, Password, QR Code, Lorem Ipsum, Cron, .gitignore, README, Meta Tags, Box Shadow

Testers: Regex, Diff Viewer, HTTP Status, Word Counter

All free, all local, no signup required.

Bonus: Free developer ebook

I also put together a free guide: The Complete Developer Toolkit 2026 — 200+ resources, Git commands, CSS patterns, JavaScript tips, security checklist, and more.

Free download (no signup): lucasmdevdev.github.io/ebook-developer-toolkit-2026

Feedback welcome — what tools are you missing? I'll add them.