DEV Community: Shawon Saha

Meet Ponytail: Putting the "Lazy Senior Dev" Inside Your AI Coding Agent

Shawon Saha — Wed, 07 Oct 2026 16:27:53 +0000

You know him. Long hair tied back, wire-rimmed glasses, terminal background set to #0e0d0b. He's been at the company longer than git. You bring him fifty lines of shiny architectural boilerplate; he looks at your screen, sighs, deletes forty-nine of them, and leaves one. It runs faster, never breaks, and requires zero maintenance.

Now imagine if your AI coding agent acted like him instead of an eager junior developer trying to impress everyone with Design Patterns™.

That is the exact philosophy behind Ponytail (DietrichGebert/ponytail), a ruleset and agent skill designed to stop LLMs from drowning codebases in unnecessary abstractions.

1. The AI Over-Engineering Epidemic

AI coding assistants are undeniably powerful, but they have a chronic habit: they love to write code.

When you ask an agent to implement in-memory caching, what does it do?
It builds a CacheManager singleton with threading locks, TTL eviction queues, custom invalidation hooks, and a custom test suite. Fifty lines of code you now have to review, debug, and maintain forever.

# What typical agents write: 50 lines of boilerplate
class CacheManager:
    def __init__(self, ttl: int = 300, maxsize: int = 1000):
        self._store = {}
        self._lock = Lock()
        self._ttl = ttl
    def get(self, key): ...
    def set(self, key, value): ...
    # ...45 more lines you now own for life

What did the task actually need?

# What Ponytail writes:
from functools import lru_cache

@lru_cache(maxsize=1000)
def fetch_user_data(user_id: str):
    ...

One line. Same behavior. Zero bugs in code that doesn't exist.

Because LLMs are trained to maximize helpfulness and output tokens, they defaults to creating rather than conserving. Every line of code added is future tech debt, another surface area for regressions, and more tokens burned per interaction.

2. The Core Philosophy: "The Ladder of Simplicity"

Ponytail forces the agent through a strict decision tree before it types a single character:

[1] Does this need to exist? (Speculative need? Skip it. YAGNI.)
     ↓ No
[2] Already in this codebase? (Reuse existing utils & helpers.)
     ↓ No
[3] Does the standard library do it? (stdlib first: functools, pathlib, os, crypto.)
     ↓ No
[4] Does a native platform feature cover it? (<input type="date"> over a 10MB npm package.)
     ↓ No
[5] Does an already-installed dependency solve it? (Don't npm install another one.)
     ↓ No
[6] Can it be one line? (One line.)
     ↓ No
[7] Minimum code that works. (Never cut security, validation, or accessibility.)

Ponytail stops at the first rung that holds.

3. Real Benchmarks: Less Code, Fewer Tokens, Same Safety

Ponytail isn't just an aesthetic stance—the benchmark numbers across real-world FastAPI + React benchmark tasks speak for themselves:

Metric	Impact
Lines of Code Written	-54% (up to -94% on certain refactorings)
Token Consumption	-22% fewer tokens
API Cost	-20% cheaper per session
Generation Speed	+27% faster turnaround
Safety Kept	100% (Validation, error handling, security, and a11y are never cut)

Ponytail doesn't sacrifice security or edge-case handling. Input validation, error states, and accessibility remain intact—it simply refuses to construct speculative scaffolding.

4. Pick Your Laziness: Intensity Modes

Ponytail comes with three distinct operational modes depending on how aggressive you want it to be:

/ponytail lite | full | ultra | off

lite: Builds what you asked for, but appends a single line pointing out the simpler, lazier alternative so you can choose.
full (Default): Enforces the ladder strictly. Standard library and native features first, minimal diffs, zero speculative abstractions.
ultra: YAGNI extremist mode. Ships the absolute one-liner and openly questions why the ticket even exists in the first place. Use this when a codebase has wronged you personally.

5. Built-In Workflow Commands

Ponytail is more than a passive system prompt—it ships with a complete toolset for reviewing and auditing:

/ponytail-review: Runs a targeted code review on your git diff, hunting exclusively for bloat: unneeded dependencies, reinvented standard library functions, and dead flexibility.
/ponytail-audit: Scans the entire repository to produce a ranked list of things to delete or replace with native alternatives.
/ponytail-debt: Scans your codebase for all # ponytail: deferral comments and compiles them into a tracked debt ledger so shortcuts don't get lost in the void.
/ponytail-gain: Displays your aggregate benchmark impact scoreboard (tokens saved, diff reductions).

6. How to Install Ponytail

Ponytail works across 20+ AI developer environments:

Claude Code

Run these two prompts in your session:

/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail

Gemini CLI / Antigravity CLI (`agy`)

# Gemini CLI
gemini extensions install https://github.com/DietrichGebert/ponytail

# Antigravity CLI (agy)
agy plugin install https://github.com/DietrichGebert/ponytail

GitHub Copilot CLI & Codex

# GitHub Copilot
copilot plugin marketplace add DietrichGebert/ponytail
copilot plugin install ponytail@ponytail

# Codex
codex plugin marketplace add DietrichGebert/ponytail
codex plugin add ponytail@ponytail

Cursor, Windsurf, OpenCode & Generic Agents

Simply copy AGENTS.md or skills/ponytail/SKILL.md into your repository's .agents/rules/ or rules directory.

Final Thoughts: The Best Code is the Code Never Written

In an era where AI models can generate 500 lines of code in seconds, developer skill is no longer measured by how much code you can produce. It’s measured by your restraint—how much unnecessary complexity you can keep out of your production systems.

Give your AI agent a ponytail. It will say less, write less, and save your team from 3:00 AM on-call pages.

How to Push and Sync Every Local Git Branch in a Single Terminal Command

Shawon Saha — Tue, 06 Oct 2026 15:33:42 +0000

When juggling multiple feature experiments, prototype branches, and quick hotfixes across a complex project, you often end up with a dozen local branches that haven't been pushed to GitHub.

Running git checkout <branch> followed by git push -u origin <branch> for ten different branches is tedious and error-prone.

Here is the exact one-line command to sync every local branch, commit pending work, and set up upstream tracking automatically.

The TL;DR: The One-Liner

If you just want the magic command to run in your terminal:

git push --all origin -u

What This Does:

git push: Sends commits to the remote repository.
--all: Pushes every local branch under refs/heads/, not just the one currently checked out.
origin: The target remote repository.
-u (or --set-upstream): Configures each branch so future git pull and git push commands know their remote counterpart without extra arguments.

What If You Have Uncommitted Changes Too?

git push --all origin -u only pushes commits that already exist. If you have uncommitted changes on your active branch and want a single command that stages, commits, and pushes everything, chain it with:

git add -A && git commit -m "chore: sync all updates" && git push --all origin -u

(If there are no uncommitted changes, the commit step will safely exit with a notice, so you can make it resilient by using git diff-index --quiet HEAD || ...).

The Ultimate Automation: A Custom Git Alias

Remembering long bash strings or typing them out repeatedly slows you down. Turn this into a native Git command by adding an alias:

Step 1: Add the Alias to Your Global Git Config

Run this once in your terminal:

git config --global alias.sync-all '!f() { \
  if ! git diff-index --quiet HEAD --; then \
    echo "Staging & committing local changes..."; \
    git add -A && git commit -m "${1:-chore: sync all updates}"; \
  fi; \
  echo "Pushing all local branches and setting upstream..."; \
  git push --all origin -u; \
}; f'

Step 2: Use It Anytime

From any Git repository on your machine, simply run:

git sync-all

Or pass a custom commit message:

git sync-all "feat: sync experiments and docs"

How It Works Under the Hood

1. `git push --all` vs. standard `git push`

Standard git push operates based on your push.default setting (usually simple), which only pushes the active branch.

Using --all instructs Git to match all local refs in .git/refs/heads/ and mirror them to the remote server under the same name:

refs/heads/feature-a ➔ refs/remotes/origin/feature-a
refs/heads/hotfix ➔ refs/remotes/origin/hotfix

2. Upstream Tracking (`-u`)

Without -u, branches pushed via --all may be pushed to GitHub, but your local repository might not associate them with origin/<branch>. Adding -u writes entries into .git/config:

[branch "main-optimized-v2.1"]
    remote = origin
    merge = refs/heads/main-optimized-v2.1

This guarantees that running git status on any branch will immediately show whether you are ahead or behind the remote.

Pro Tip: Pushing Tags Too

If your workflow also relies on local git tags (such as release versions or milestones), git push --all deliberately ignores tags. To push both branches and tags in one shot:

git push --all origin -u && git push --tags origin

Summary Cheat Sheet

Task	Command
Push all local branches + link upstream	`git push --all origin -u`
Commit active edits + push all branches	`git add -A && git commit -m "sync" && git push --all origin -u`
Push everything including tags	`git push --all origin -u && git push --tags origin`
Permanent 1-word shortcut	`git sync-all` (after configuring alias)

How to Generate Ultra-High-Resolution Video Contact Sheets with vcsi

Shawon Saha — Tue, 29 Sep 2026 09:39:40 +0000

Video contact sheets—also known as thumbnail preview grids—are the fastest way to inspect footage, catalog archival video libraries, or share visual overviews without streaming or transferring multi-gigabyte media files. While media players like VLC or MPC-HC can generate basic thumbnail sheets, they often output heavily compressed, low-resolution files where small details, motion blur, and sharp subtitles turn into muddy artifacts.

vcsi (Video Contact Sheet Instruction) is a lightweight CLI utility powered by Python and FFmpeg that solves this issue. It allows you to produce crystal-clear, custom-dimensioned, publication-ready contact sheets directly from the command line.

1. Installation and Prerequisites

vcsi acts as a wrapper around FFmpeg and the Pillow imaging library. To run it on macOS or Linux, ensure you have FFmpeg and Python installed.

On macOS using Homebrew:

# Install FFmpeg
brew install ffmpeg

# Install vcsi via pip
pip3 install vcsi

On Ubuntu or Debian:

sudo apt update
sudo apt install ffmpeg python3-pip
pip3 install vcsi

Once installed, verify the setup by running:

vcsi --version

2. Generating Ultra-High-Resolution Sheets

By default, vcsi restricts image output to a fixed width of 1500 pixels. Across a 4×4 grid of a 4K file, each individual frame shrinks to roughly 375 pixels wide, losing fine textures. You can override this using either custom canvas scaling or true 1:1 pixel rendering.

Method A: Fixed 4K or 8K Canvas Output

If you need uniform file dimensions for web uploads, image hosting, or documentation, explicitly specify the canvas width using -w:

# 4K preview sheet (3840px wide)
vcsi "source_video.mp4" -g 4x4 -w 3840 -a --quality 100 -o "preview_4k.jpg"

# 8K preview sheet (7680px wide)
vcsi "source_video.mp4" -g 4x4 -w 7680 -a --quality 100 -o "preview_8k.jpg"

-g 4x4: Generates a grid with 4 columns and 4 rows (16 captures total).
-w 3840: Forces the horizontal canvas width to 3840 pixels while maintaining aspect ratio.
-a / --accurate: Forces FFmpeg to decode exact target timestamps rather than snapping to the nearest I-frame, eliminating gray blocks and decoding artifacts on modern HEVC/AV1 footage.
--quality 100: Disables aggressive JPEG compression.

Method B: Native 1:1 Source Resolution

For master archives, studio delivery, or high-fidelity technical reviews, use the -S flag to bypass all scaling:

vcsi "source_video.mp4" -g 3x4 -S -a -f png -o "preview_native.png"

-S / --actual-size: Each thumbnail inside the sheet renders at the native pixel resolution of the source video. A 3×4 grid of a 1080p source outputs an uncompressed composite over 5,700 pixels wide.
-f png: Employs lossless PNG output rather than lossy JPEG compression.

3. Formatting Typography for Hi-DPI Displays

When scaling canvas dimensions up to 4K or 8K, default headers and timestamp overlays will appear microscopic. vcsi allows you to scale metadata typography independently to match higher resolutions:

vcsi "source_video.mp4" \
  -g 4x4 \
  -w 3840 \
  -a \
  --metadata-font-size 28 \
  --timestamp-font-size 22 \
  --timestamp-border-size 2 \
  --grid-spacing 12 \
  -o "preview_styled.jpg"

--metadata-font-size: Scales the top header block containing the filename, duration, audio/video codecs, and container details.
--timestamp-font-size: Enlarges the timecode stamped into the lower corner of each frame.
--grid-spacing: Adds padding (in pixels) between grid tiles to prevent adjacent frames from visually running together.

4. Automating Batch Processing Across a Directory

Generating contact sheets for an entire folder of video files takes just a standard shell loop:

#!/usr/bin/env bash

# Loop through all MP4 and MKV files in the current folder
for file in *.{mp4,mkv}; do
  # Skip loop if no matching files exist
  [ -e "$file" ] || continue

  echo "Processing: $file"
  vcsi "$file" \
    -g 4x4 \
    -w 3840 \
    -a \
    --metadata-font-size 26 \
    --timestamp-font-size 20 \
    -o "${file%.*}_contact_sheet.jpg"
done

Pairing vcsi with FFmpeg delivers total control over video preview workflows, from single-frame precision to pixel-perfect high-DPI sheets that look razor-sharp on any monitor.

How to Truly Full-Screen Window in macOS Stage Manager (Even with an External Keyboard!)

Shawon Saha — Sat, 19 Sep 2026 09:20:30 +0000

Have you ever settled in to work on your Mac, turned on Apple’s Stage Manager to keep your desktop organized, and tried to maximize a window—only to watch macOS stubbornly leave a giant empty strip on the left side of your screen?

If you use window-snapping apps like Rectangle, you’ve likely noticed the problem: hitting your maximize shortcut expands the window, but it stops short by about 15% to 20%, reserving precious real estate for Stage Manager’s app thumbnails.

Even worse, when you finally discover macOS’s built-in "Fill" shortcut (Fn + Control + F), it works like a dream on your MacBook keyboard—until you plug in a Bluetooth keyboard like the Logitech Pebble, and suddenly nothing happens at all.

Here is what is happening behind the scenes, why your external keyboard refuses to cooperate, and how to fix it in under two minutes.

1. The Real Issue: "Full Screen" vs. "Fill"

Before fixing the shortcut, it helps to understand how modern macOS treats window sizes:

Method	What It Does	Stage Manager Impact
Green Button / Full Screen (`Control + Cmd + F`)	Flings the app into a completely separate "Space" screen	Hides Stage Manager and your other apps entirely
Rectangle App Maximize (Default)	Expands the window within visible boundaries	Leaves a 20% empty shelf on the side
macOS Native "Fill"	Stretches the window edge-to-edge on your current desktop	Keeps Stage Manager active and auto-hides the shelf until you hover over it

The Fill command is what most people actually want: maximum screen space on the active desktop without isolating the app into its own virtual monitor space.

2. The Mystery: Why `Fn + Control + F` Breaks on External Keyboards

On your MacBook’s built-in keyboard, pressing Fn + Control + F immediately triggers "Fill."

So why does it fail on external keyboards like the Logitech Pebble (K380, Pebble Keys 2, or standard mechanical keyboards)?

On a Mac keyboard: The Fn key is a native modifier recognized directly by macOS (acting as both Fn and the Globe key).
On third-party keyboards: The Fn key is usually processed inside the keyboard itself to control hardware features like media volume, screen brightness, or device switching.

Because the keyboard never actually sends an Fn signal to macOS, your Mac only receives Control + F—and ignores the command.

3. The 2-Minute Fix: Make "Fill" Work Everywhere

You don't need to buy an Apple Magic Keyboard to fix this. You just need to assign the "Fill" command to a shortcut that doesn't use the Fn key.

Step 1: Open System Settings

Click the Apple logo () in the top-left corner of your screen.
Select System Settings.
In the sidebar, scroll down and click Keyboard, then click the Keyboard Shortcuts… button.

Step 2: Create a Custom Shortcut for "Fill"

In the window that pops up, select App Shortcuts on the left.
Click the + (plus) button at the bottom of the list.
Keep Application set to All Applications.
In the Menu Title field, type Fill exactly as shown (capital "F", no punctuation—it must match Apple’s menu bar item).
In the Keyboard Shortcut field, press a combination of standard modifier keys, such as:
Control + Option + F (Recommended)
Click Done.

Step 3: Put Your Logitech Pebble in "Mac Mode"

External keyboards often share layouts between Windows and macOS. To ensure the keys align correctly:

Press and hold Fn + O on your Logitech keyboard for 3 seconds.
The Bluetooth LED will flash, confirming the keyboard is now mapped to Apple modifier keys (Control, Option, and Command).

Test it out: Select any app window and press Control + Option + F on your Pebble keyboard. The window will immediately snap edge-to-edge, hiding the Stage Manager rail until your cursor touches the side of the display!

4. Bonus: Love the Rectangle App? Remove the Gap Permanently

If you already have strong muscle memory for Rectangle’s maximize shortcut, you don't even have to leave it behind. You can tell Rectangle to stop reserving space for Stage Manager:

Click the Rectangle icon in your menu bar and select Quit Rectangle.
Press Command + Space, type Terminal, and press Enter.
Copy and paste the following line, then press Enter:

defaults write com.knollsoft.Rectangle stageSize -float 0

Re-open Rectangle.

Now, when you hit your usual Rectangle shortcut, your window will stretch across 100% of your screen width automatically.

Set Up Lightning-Fast Codebase Indexing in Zoo Code / Roo Code / Cline with Ollama (BGE-M3) and Qdrant

Shawon Saha — Thu, 17 Sep 2026 07:18:12 +0000

Nothing kills developer momentum quite like watching Roo Code freeze at 60 / 3483 blocks because a cloud API slapped you with an HTTP 429: Too Many Requests error.

Cloud-based embedding models like Gemini or OpenAI are convenient to set up, but when indexing an entire codebase, they quickly introduce rate limits, slow exponential backoffs, recurring token costs, and privacy concerns regarding proprietary code leaving your local machine.

The fix? A local, zero-cost, privacy-first semantic search pipeline using Ollama, the high-performance BAAI/bge-m3 embedding model, and Qdrant.

Here is a complete, step-by-step guide to setting up instantaneous codebase indexing in Roo Code.

Why the BGE-M3 + Qdrant Stack Wins

Semantic search in an IDE agent requires more than standard string matching (grep). It chunks functions, hooks, and types into high-dimensional vector representations so the LLM can resolve abstract natural-language requests—like "where do we handle session refresh tokens?"—into concrete file locations.

Feature	Cloud APIs (Gemini Free / OpenAI)	Local Ollama (`bge-m3`)
Indexing Speed (~1,000 blocks)	15–20 minutes (rate-limit stalls)	15–30 seconds
Rate Limits	Stalls every 60 blocks (HTTP 429)	Zero (completely local)
Context Window	2,048 tokens	8,192 tokens (full components & files)
Cost & Privacy	Pay-per-token; code leaves machine	100% free, offline, and private
Vector Storage	Ephemeral or remote cloud	Persistent, low-latency Qdrant index

What Makes BGE-M3 Special?

Massive 8,192-Token Context Window: Lightweight embedding models (like all-MiniLM-L6-v2) truncate inputs after 256 or 512 tokens, slicing large functions and interfaces in half. bge-m3 embeds extensive React components, API routes, and type schemas in a single cohesive vector.
1024-Dimension Semantic Resolution: Trained on massive multilingual and technical corpora, bge-m3 understands code semantics and structural syntax with exceptional accuracy.
CPU and GPU Efficient: Despite its 567M parameter density, it indexes repositories in seconds even on mid-tier modern processors.

Prerequisites

Before getting started, ensure you have:

VS Code with the Roo Code extension installed.
Ollama installed and running on your system (Download Ollama).
An active Qdrant instance (either a free Qdrant Cloud cluster or a local Docker instance running on localhost:6333).

Step 1: Pull the BGE-M3 Model in Ollama

Open your terminal and download the bge-m3 model:

ollama pull bge-m3

Verify that the model downloaded successfully and Ollama's local server is responding:

ollama list
curl http://localhost:11434/api/tags

You should see bge-m3 (~1.2 GB) in your list of local models.

Step 2: Prevent Index Bloat with a `.rooignore` File

By default, Roo Code scans build outputs, cache directories, and package lockfiles. A single package-lock.json or pnpm-lock.yaml can contain tens of thousands of lines of metadata, bloating your index by thousands of unnecessary blocks and slowing down search.

Create a .rooignore file in your project's root directory:

# Package Managers & Dependencies
node_modules/
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb

# Build Outputs & Framework Caches
.next/
out/
build/
dist/
.vercel/
.turbo/

# Static Assets & Media
public/
*.svg
*.png
*.jpg
*.jpeg
*.webp
*.ico

# Version Control & Secrets
.git/
.env*
*.log

# Types & Caches
*.tsbuildinfo
next-env.d.ts

Tip: Adding this file typically cuts a standard Next.js or React repository from 3,500+ blocks down to 300–800 blocks of actual application logic.

Step 3: Clear Stale Vector Data (Crucial Step!)

If you previously started indexing using Gemini (3072 dimensions) or OpenAI (1536 dimensions), your existing Qdrant collection is locked to that vector size. Pushing 1024-dimension vectors from bge-m3 without wiping will cause dimension mismatch errors.

Open VS Code and open the Roo Code panel.
Navigate to the Codebase Indexing configuration screen.
Click Stop Indexing if a previous run is frozen.
Expand Advanced Configuration.
Click Clear Index Data.

This cleanly purges the old collection and resets the indexing status.

Step 4: Configure Roo Code Settings

In the Codebase Indexing settings pane, enter the following parameters:

Embedder Provider: Ollama
Ollama Base URL: http://localhost:11434
Model: bge-m3
Model Dimension: 1024 (Make sure this is set to 1024, not 1536 or 3072)
Qdrant URL: Your Qdrant endpoint (e.g., https://xxxx.eu-west-1-0.aws.cloud.qdrant.io:6333 or http://localhost:6333)
Qdrant API Key: Your Qdrant authentication token (leave blank if running local unauthenticated Qdrant)

Step 5: Save and Start Indexing

Check the box for Enable Codebase Indexing.
Click Save in the bottom-right corner.

Watch the progress bar: instead of stalling every 60 blocks, the counter will continuously progress from 0 / 840 to completion in 15 to 30 seconds.

Once complete, the status indicator turns green:

Status: Indexed - File watcher started.

What Happens Next?

Automatic Incremental Indexing: The active file watcher monitors your workspace. When you write new code or edit existing files, Roo Code re-indexes only the modified files through Ollama in milliseconds.
Instant Context for Roo Code: When you ask Roo Code questions like "where do we handle payment webhooks?" or "refactor the authentication middleware", it queries Qdrant using vector similarity to retrieve the exact files needed before generating code.
Zero Monthly Bills: You get infinite embeddings and searches without consuming API credits or depending on cloud connectivity.

The Ultimate Guide to Downloading Videos Like a Pro (Plus an Easy No-Terminal Alternative)

Shawon Saha — Wed, 26 Aug 2026 06:50:05 +0000

If you’ve ever tried downloading videos from the internet, you’ve probably run into limitations—low quality, watermarks, or sketchy websites. That’s where yt-dlp comes in.

yt-dlp is one of the most powerful, flexible, and reliable tools for downloading videos and audio from thousands of websites. It’s open-source, actively maintained, and supports 1700+ platforms.

But there’s a catch: it’s a command-line tool. That scares a lot of people.

Don’t worry. In this guide, I’ll walk you through:

What yt-dlp is
How to use it step by step
Practical commands you’ll actually use
And a bonus no-terminal solution for beginners

What is yt-dlp?

yt-dlp is a command-line program that lets you:

Download videos in the best available quality
Extract audio (MP3, FLAC, etc.)
Download playlists and channels
Add subtitles, metadata, thumbnails, and more
✅ Download multiple audio tracks (different languages / dubs)

It’s essentially a more advanced and actively maintained version of youtube-dl.

Why Use yt-dlp?

Here’s why power users love it:

🎯 Maximum quality downloads (4K, 8K, HDR)
⚡ Fast and reliable
🌍 Supports thousands of sites
🔧 Fully customizable
🧠 Smart format selection
🌐 Multi-audio & dubbed version support

🔥 Standout Feature: Multiple Audio & Dubbed Versions

One of the most underrated features of yt-dlp is the ability to download multiple audio streams from the same video.

Many platforms (like YouTube, Netflix-style streams, or anime sites) provide:

Different languages (English, Hindi, Japanese, etc.)
Different dubbed versions
Multiple audio quality tracks

yt-dlp lets you access and download them.

🔍 List available audio tracks

yt-dlp -F "URL"

You’ll see multiple audio formats like:

audio-eng
audio-hin
audio-jpn

🎧 Download a specific language

yt-dlp -f "ba[language=en]" "URL"

🌍 Download multiple audio tracks together

yt-dlp -f "ba[language=en]+ba[language=hi]" "URL"

🎬 Download video with specific dubbed audio

yt-dlp -f "bv+ba[language=ja]" "URL"

📦 Embed multiple audio tracks into one file (MKV)

yt-dlp -f "bv+ba[language=en]+ba[language=hi]" --merge-output-format mkv "URL"

This creates a single video file where you can switch audio tracks in your media player.

💡 Perfect for:

Watching anime with multiple dubs
Keeping original + dubbed versions
Family use (different language preferences)

Getting Started (Basic Usage)

1. Open your terminal

Windows → Command Prompt / PowerShell
macOS → Terminal
Linux → Terminal

2. Run your first command

yt-dlp "VIDEO_URL"

That’s it.

Most Useful yt-dlp Commands

🎬 Download best quality

yt-dlp "URL"

🎵 Extract audio (MP3)

yt-dlp -x --audio-format mp3 "URL"

📺 Download specific quality (e.g. 1080p)

yt-dlp -f "best[height<=1080]" "URL"

📋 Download a full playlist

yt-dlp --yes-playlist "PLAYLIST_URL"

📝 Download subtitles

yt-dlp --write-subs --embed-subs "URL"

The Problem: Not Everyone Likes the Terminal

Let’s be honest.

Typing long commands isn’t for everyone.

If you:

Don’t want to install tools
Don’t like command lines
Just want quick downloads

Then you need something simpler.

⭐ Bonus: No-Terminal Alternative

👉 https://ytdlp.online/

This tool gives you the power of yt-dlp without the setup.

Why it’s useful:

🖱️ No installation required
🧩 No commands to memorize
⚙️ Visual interface
🚀 Runs in your browser

You can:

Paste a URL
Choose quality
Select audio languages
Generate commands automatically

Final Thoughts

yt-dlp is more than just a downloader—it’s a complete media control tool.

And features like multi-audio and dubbed downloads make it incredibly powerful, especially for:

International users
Anime fans
Families with different language needs

Whether you prefer the terminal or a simple web interface, yt-dlp has you covered.

TL;DR

yt-dlp = powerful open-source downloader
Supports video, audio, subtitles, playlists
⭐ Can download multiple audio tracks & dubbed versions
Simple start:

  yt-dlp "URL"

Don’t like terminal? Use https://ytdlp.online/

The Ultimate Trick to Change Android Animation Scale with Developer Options DISABLED

Shawon Saha — Sat, 04 Jul 2026 10:15:26 +0000

We’ve all done it: the very first thing you do when you get a new Android phone is unlock Developer Options and drop the animation scales from 1.0x to 0.5x. Instantly, your phone feels twice as fast. Apps snap open, multitasking feels fluid, and that artificial lag is completely gone.

But then, you try to open your banking app, a high-security crypto wallet, or a sensitive work app, only to be met with a dreaded security warning:

"Security Risk Detected: Developer Options are enabled. Please disable them to use this app."

It’s an incredibly frustrating ultimatum. Do you choose a snappier, faster user interface, or do you choose being able to access your money on the go?

Thankfully, you don't have to choose anymore. In this guide, we’re going to show you a permanent workaround using an open-source tool called CustomAnimator by Ahmet Can Arslan. You will learn how to set a custom animation scale and completely turn off Developer Options while keeping your lightning-fast UI.

Why Do Banking Apps Care About Developer Options?

To understand why this workaround is so great, you have to understand the security risk. When Developer Options are left enabled, your device leaves the door open for USB Debugging (adb). In the wrong hands, an authorized computer could sideload malware, extract app data, or simulate touches.

To protect your financial data, banking apps simply look for the system flag development_settings_enabled. If it’s on, they lock you out.

Our goal is to change the animation settings directly inside Android's Secure Settings layer, grant a tiny open-source app the right to handle it, and then flip that developer flag safely back to Off.

What You Need

An Android phone.
A computer (Windows, Mac, or Linux) and a USB cable.
The CustomAnimator app installed on your phone. You can grab the APK directly from the Official CustomAnimator GitHub Repository.

Step 1: Prepare Your Android Device

Before we touch the computer, we need to allow it to speak to your phone just this once.

On your phone, go to Settings > About Phone.
Find the Build Number and tap it 7 times until it says "You are now a developer!"
Go back to your main Settings, search for Developer Options, and turn on USB Debugging.
Connect your phone to your computer using a reliable USB cable.

⚠️ Crucial Step for Brand-Specific Phones:

Some manufacturers add extra security layers that block automated permission scripts. If you have one of these devices, change this setting before moving forward:

OnePlus / Oppo / Realme (OxygenOS 16 / ColorOS): Scroll to the very bottom of Developer Options and turn ON "Disable system optimization".
Xiaomi / Poco / Redmi: Turn ON "USB debugging (Security settings)" (right below the main USB debugging switch) and bypass the warning timers.

Step 2: Install ADB on Your Computer

Choose your computer's operating system below to get Android Platform Tools (ADB) running in seconds.

For macOS Users

The fastest way to install ADB on a Mac is via Homebrew. Open your Terminal app and run:

brew install android-platform-tools

(If you don't use Homebrew, download the official SDK Platform-Tools for Mac ZIP, extract it, and open Terminal inside that folder.)

For Windows Users

Download the official SDK Platform-Tools for Windows ZIP.
Extract the folder to an easy-to-find location (like C:\platform-tools).
Click on your Windows start menu, type CMD (Command Prompt), and open it.
Point the command prompt to your folder by running:

cd C:\platform-tools

For Linux Users

If you are on Linux, you can install ADB directly from your distribution's native package manager. Open your terminal and type:

Ubuntu/Debian: sudo apt install adb
Fedora: sudo dnf install android-tools
Arch Linux: sudo pacman -S android-tools

Step 3: Link Your Computer and Phone

With your terminal or command prompt open, let's verify the connection. Run the following command:

Mac & Linux: adb devices
Windows (Command Prompt): adb devices
Windows (PowerShell): .\adb devices

Look at your phone's screen immediately. A popup will ask you to "Allow USB debugging?". Check the box for Always allow from this computer and tap Allow.

When you run the command a second time, you should see your phone's serial number followed by the word device.

Step 4: Grant the Permanent Secure Permission

Now we are going to use the Android Package Manager (pm) to grant CustomAnimator the right to modify system animations without root access. Copy and paste the command for your OS:

Mac, Linux & Windows CMD:

adb shell pm grant com.arslan.customanimator android.permission.WRITE_SECURE_SETTINGS

Windows PowerShell:

.\adb shell pm grant com.arslan.customanimator android.permission.WRITE_SECURE_SETTINGS

Hit Enter. If the terminal simply jumps down to a blank new line without showing any errors, it worked perfectly!

Step 5: Set Your Animations and Lock the Door!

Now you can disconnect your phone from the computer. The hard work is done.

Open the CustomAnimator app on your Android device.
The permission error screen will be gone, replaced by a clean menu. You can now set your Window, Transition, and Animator scales exactly how you like them (e.g., 0.5, 0.25, or even completely custom values like 0.35).
Once your phone feels perfectly snappy, go to Settings > Developer Options.
Toggle the main "Developer Options" switch to OFF.

(Note: If you had to toggle "Disable system optimization" or "USB Debugging Security Settings" in Step 1, turning off Developer Options will automatically safely revert those too).

The Result?

Open up your banking app, Google Pay, or your corporate email. They will read the system flag, see that Developer Options are completely disabled, and grant you full access instantly. Meanwhile, your underlying animation scales remain set exactly where CustomAnimator put them.

You get a faster phone, maximum security, and zero app crashes. It’s the ultimate win-win for Android power users!

Unlock the Hidden Power of Your Mac: Why You Aren't Using the Option Key Enough

Shawon Saha — Thu, 25 Jun 2026 14:12:05 +0000

We’ve all been there: you’re working on your Mac, clicking through menus, and thinking, “There has to be a faster way to do this.” As it turns out, the answer has been sitting right under your fingertips the entire time. The Option key {⌥} is easily one of the most underrated, underutilized tools on a Mac. While it might just look like a modifier key for typing special symbols, it actually unlocks a massive world of hidden features, deep system analytics, and lightning-fast workflows.

If you want to save time and boost your daily productivity, here are the best hidden Option key shortcuts you need to start using right now.

1. Next-Level File Management in Finder

The Dynamic "Inspector" Window

Normally, when you want to see a file's details, you right-click and select Get Info (or press Command + I). But if you select multiple files, your screen instantly gets cluttered with dozens of individual windows.

The Upgrade: Press Command + Option + I.
Why it’s better: This opens a single, dynamic Inspector window. Instead of opening new tabs, the Inspector automatically updates its information in real-time as you click through different files.

Permanent File Deletion

Tired of dragging files to the Trash and having to empty it manually later to free up SSD space?

The Upgrade: Select your file and press Command + Option + Delete.
Warning: This completely bypasses the Trash and permanently deletes the file immediately. Use it with caution, because there is no "undo" button here!

2. Desktop & Window Management Mastery

Mass-Minimize Windows

When your desktop becomes a chaotic mess of Safari windows, minimizing them one by one is incredibly tedious.

The Shortcut: Hold Option while clicking the yellow minimize button on the top-left of a window.
The Result: Every single open window of that specific app will minimize simultaneously in one quick swoop.

Instant "Focus Mode"

If overlapping apps are distracting you and you need to focus entirely on just one (like the Notes app), you don't have to minimize everything else manually.

The Shortcut: Click the app you want to use, then press Command + Option + H.
The Result: This instantly hides every other background application, leaving only your active window visible.

The Smart App Quit

When you have dozens of browser tabs open for a massive research project, quitting the app (Command + Q) usually means losing your spot or hoarding system RAM for days.

The Shortcut: Use Command + Option + Q.
The Result: This acts like a "pause" button. It safely shuts down the app to free up your system RAM, but when you reopen it, every single window and tab will restore exactly where you left off.

💡 Bonus Tip: Want to maximize a window to fill your screen without entering Apple's rigid Full Screen mode? Hold Option while clicking the green maximize button in the top-left corner.

3. Secret Menu Bar Diagnostis

Your Mac's menu bar holds deep, hidden secrets—all you have to do is hold Option before you click:

Icon	Normal Click	Option + Click
Wi-Fi Icon	Shows available networks.	Displays advanced connection parameters and troubleshooting metrics.
Sound Icon	Adjusts the volume slider.	Instantly lists all available audio hardware input and output devices (speakers, headphones, mics).
Apple Logo 	Opens basic "About This Mac" menu.	Changes the first option to System Information, taking you straight to deep hardware and spec data.

4. Micro-Adjustments for Audio and Brightness

If standard volume and brightness steps feel too drastic, the Option key gives you granular control:

Quick Settings Access: Pressing Option + Volume Key instantly opens your Sound System Settings directly, skipping manual navigation.
Micro-Stepping: Hold Shift + Option while pressing the Volume or Brightness keys. This adjusts the levels in tiny, precise fractions rather than full blocks, allowing you to perfectly dial in your environment.

5. High-Speed Text Editing

For anyone editing long documents, articles, or code, navigating text using a mouse is a massive bottleneck. Memorize these shortcuts to move at warp speed:

Move by Word: Press Option + Left/Right Arrow to skip the cursor forward or backward one entire word at a time.
Move by Paragraph: Press Option + Up/Down Arrow to jump the cursor up or down by a full line/paragraph.
Speed Selection: Combine these with Shift (Shift + Option + Arrows) to instantly highlight entire words or full sentences at a time.

6. The Ultimate Panic Button: Force Quit

When an application completely freezes, your mouse stops responding, and the spinning beachball of death appears, do not panic and do not hard-restart your computer.

The Shortcut: Press Command + Option + Escape.
The Result: This immediately fires up the Force Quit Applications window. Simply use your keyboard's arrow keys to highlight the frozen app, hit Enter, and it will instantly terminate the application without disrupting the rest of your system.

Conclusion: Work Smarter, Not Harder

The Mac ecosystem is packed with subtle engineering choices designed to make power users faster, and the Option key is the gateway to most of them. By integrating just two or three of these habits into your daily routine, you'll cut out hours of tedious clicking over time.

How to Move Git Commits to a New Branch With Updated Timestamps

Shawon Saha — Wed, 24 Jun 2026 07:56:35 +0000

Ever needed to move a batch of commits from one branch to another — and make them look like they happened right now? Maybe you're cleaning up your Git history before opening a PR, or reorganizing work across branches after the fact.

Whatever the reason, Git makes this surprisingly doable. Here's how.

The Scenario

You're on a branch called feature-branch and the last 6 commits need to move to a brand new branch called clean-branch. You also want every commit's timestamp to reflect the current time instead of when you originally wrote the code.

By the end of this tutorial:

✅ A new branch will have your commits with fresh timestamps
✅ The original branch will no longer contain those commits
✅ All commit messages and file changes stay intact

Step 1: Note Your Commit Hashes

First, grab the hashes of the commits you want to move. We'll list them oldest-first so they replay in the right order:

git log -6 --reverse --pretty=format:"%h %s"

You'll see something like:

a1b2c3d feat: add user settings page
d4e5f6a fix: sidebar alignment on mobile
...

Step 2: Create the New Branch

Create your new branch starting from the point before those 6 commits:

git checkout -b clean-branch HEAD~6

This puts you on clean-branch, which currently has everything your original branch had except the last 6 commits.

What does HEAD~6 mean?
It means "the commit that is 6 steps before the current one." So the new branch starts right where those 6 commits began.

Step 3: Cherry-Pick With New Timestamps

Now replay each commit onto the new branch, but override the timestamp. Replace the hashes below with your actual ones from Step 1:

NOW="2026-06-24T02:50:33+06:00"

for hash in a1b2c3d d4e5f6a g7h8i9j k0l1m2n o3p4q5r s6t7u8v; do
  GIT_AUTHOR_DATE="$NOW" GIT_COMMITTER_DATE="$NOW" git cherry-pick --no-edit "$hash"
done

Replace the NOW value with your desired timestamp, or use the current time dynamically:

NOW=$(date -Iseconds)

Wait — Git has two dates?

Yes! Every commit stores two timestamps:

Date	What it means
Author date	When the change was originally written
Committer date	When the commit was last applied (rebased, cherry-picked, amended)

Tools like GitHub show the author date by default. The GIT_AUTHOR_DATE and GIT_COMMITTER_DATE environment variables let you override both.

Step 4: Verify the Timestamps

Confirm that both dates were updated:

git log -6 --pretty=format:"%h | %s | Author: %ad | Committer: %cd" --date=iso

Every commit should now show your chosen timestamp for both fields.

Step 5: Remove the Commits From the Original Branch

The commits still exist on your original branch. To "move" them (not just copy), reset that branch back:

git branch -f feature-branch feature-branch~6

This rewrites the feature-branch pointer to exclude the last 6 commits. Since you've already got them on clean-branch, nothing is lost.

The Quick Version

If you want the whole thing as a copy-paste script:

# Config — edit these
SOURCE_BRANCH="feature-branch"
NEW_BRANCH="clean-branch"
NUM_COMMITS=6
NOW=$(date -Iseconds)

# 1. Get commit hashes (oldest first)
HASHES=$(git log -$NUM_COMMITS --reverse --pretty=format:"%h")

# 2. Create new branch from before those commits
git checkout -b $NEW_BRANCH ${SOURCE_BRANCH}~${NUM_COMMITS}

# 3. Cherry-pick with updated timestamps
for hash in $HASHES; do
  GIT_AUTHOR_DATE="$NOW" GIT_COMMITTER_DATE="$NOW" git cherry-pick --no-edit "$hash"
done

# 4. Remove commits from original branch
git branch -f $SOURCE_BRANCH ${SOURCE_BRANCH}~${NUM_COMMITS}

# 5. Verify
git log -$NUM_COMMITS --pretty=format:"%h | %ad | %s" --date=iso

Good to Know

This rewrites history. The new commits will have different hashes. If the original branch was already pushed, you'll need to force-push (git push --force) — coordinate with your team first.
Cherry-pick preserves authorship. The commit author name and email stay the same; only the dates change.
Conflicts are possible. If the commits depend on each other in tricky ways, cherry-pick will pause and ask you to resolve conflicts, just like a rebase would.
Want different timestamps per commit? Instead of a single $NOW, you can set a unique date inside the loop for each cherry-pick.

That's it — six commits, new branch, clean timestamps. Happy rebasing! 🎉

Dev Hack: How to Stop TypeScript (.ts) Files From Ruining Your macOS Smart Folders

Shawon Saha — Wed, 24 Jun 2026 07:36:33 +0000

If you are a web developer who also happens to keep a movie collection or video assets on your Mac, you’ve probably run into a deeply frustrating macOS quirk.

You decide to set up a Finder Smart Folder to track your recent video files or movies. You set the criteria to Kind is Movie, look at the results, and instead of a clean list of MP4s and MKVs, your folder is absolutely flooded with thousands of .ts files from your local development projects.

Here’s why this happens and how to permanently banish TypeScript files from your media filters without breaking Finder’s search scope.

The Problem: macOS Thinks You’re an MPEG-2 Enthusiast

By default, macOS recognizes the .ts file extension as an MPEG-2 Transport Stream—a video container format used for broadcast streaming and DVDs.

Finder has absolutely no idea that you are a modern JavaScript developer building applications. It just sees thousands of .ts source files in your node_modules or project directories and proudly flags them as "Movies."

If you try to fix this by typing -extension:ts directly into the Finder search bar, it often resets the search scope, causing your Smart Folder to completely break and return zero results.

The Fix: Using Advanced "Raw Query" Rows

To filter out TypeScript code without breaking your global search scope, you need to use Finder's hidden advanced boolean logic. Here is how to set it up step-by-step:

1. Set Up Your Base Media Filters

Open Finder, press Cmd + Option + N to create a new Smart Folder, and set up your initial include parameters using the standard + button. For example:

Kind is Movie
Last opened date is within the last 365 days

2. Reveal the Hidden Boolean Menu

Do not touch the search bar. Instead, hold down the Option (⌥) key on your keyboard. You will notice that the + buttons on the right side of your rules instantly transform into ... (Ellipsis) icons.

Click the ... button on your bottom row. This spawns a nested sub-rule block.

3. Target the `.ts` Extension Exclusively

Configure your new nested rule block to strictly target and exclude the file extension:

Change the main dropdown of this nested block from Any or All to None.
Click the first dropdown in the sub-row underneath it and select Other...
Search for "File extension", check the box next to it to enable it, and click OK.
Set the row to: File extension | is | ts

Your smart folder rules should now look exactly like this:

(Note: Replace with your screenshot if publishing!)

[Kind] is [Movie]
[Last opened date] is within last [365] [days]
└── [None] of the following are true:
    └── [File extension] is [ts]

4. Save and Forget

Click the Save button in the upper right corner, name your folder (e.g., "Recent Movies"), and keep "Add to Sidebar" checked.

Finder will now perfectly index your entire drive for actual video files while completely ignoring your development workspace. No more digging through a sea of TypeScript components just to find a video file.

Blocked by Mac Security? How to Fix “Apple Could Not Verify” Errors in Seconds

Shawon Saha — Wed, 27 May 2026 06:53:48 +0000

Getting the "Apple could not verify this app is free of malware" error on macOS? Learn 3 quick ways to bypass Gatekeeper and open blocked Mac apps safely.

We’ve all been there. You download a perfectly safe, trusted app from a developer’s website, try to open it, and macOS immediately throws a security tantrum.

The dreaded popup reads: "[App Name] Not Opened. Apple could not verify this app is free of malware..."

This is macOS Gatekeeper doing its job a little too well. If you’re 100% sure the app is safe, you don't need to throw it in the trash. Here is how to override the block and launch your app in seconds.

Method 1: Override via System Settings

If the shortcut doesn't work, you can manually grant permission through your Mac's security settings.

Click the Apple logo in the top left and open System Settings.
Navigate to Privacy & Security in the left sidebar.
Scroll down to the Security section.
You will see a notification stating your app was blocked. Click the Open Anyway button.
Enter your Mac login password or use Touch ID to confirm.

Method 2: The Terminal Nuclear Option (For Stubborn Apps)

If the app still refuses to open, macOS may have aggressively quarantined the file. You can strip the quarantine flag using a simple Terminal command.

Open the Terminal app (Press Cmd + Space and search for Terminal).
Copy and paste the following command, adding a space at the very end:

sudo xattr -rd com.apple.quarantine

Drag and drop the blocked app icon from your Applications folder directly into the Terminal window (this automatically inputs the exact file path).
Hit Enter, type your Mac's admin password (no characters will show, just type and hit Enter), and try opening the app again.

Method 3: The Right-Click Shortcut (Fastest Fix)

The absolute quickest way to bypass the macOS unidentified developer block is the secret right-click trick.

Open Finder and go to your Applications folder.
Locate the blocked app.
Right-click (or hold Control and click) the app icon, then select Open from the menu.
A new dialogue box will appear, but this time, it will include an Open button. Click it, and macOS will permanently whitelist the app.

⚠️ A Quick Safety Reminder: macOS Gatekeeper exists to protect your system. Only use these bypass methods if you downloaded the app from an official, trusted source. If you aren't sure where the app came from, it’s safer to delete it.

Fix the Notch: How to Stop macOS Hiding Your Menu Bar Icons

Shawon Saha — Sun, 24 May 2026 11:56:54 +0000

The notch on modern MacBooks gives us beautiful, near-borderless displays. But for heavy multitaskers, it introduces a frustrating design flaw: macOS hides menu bar icons behind the notch when you run out of space. Because Apple provides no native overflow menu, essential utility apps simply disappear into a digital black hole. You shouldn't have to force-quit applications just to access your status icons.

Here is how to quickly reclaim your MacBook menu bar real estate.

1. Condense Everything with "Only Switch" (Free & Open Source)

If your menu bar is cluttered with individual icons for Dark Mode, Keep Awake, Bluetooth, and Night Shift, you are wasting prime real estate.

Only Switch is a powerful, open-source utility that consolidates dozens of settings into a single menu bar icon. Clicking it reveals a clean dropdown panel of customizable toggles. By replacing five or six separate app icons with just one, you instantly clear massive space so other apps never get pushed behind the notch.

Bonus Feature: Only Switch includes a "Hide Notch" toggle that turns the menu bar background pure black, blending the notch seamlessly into the display bezel.

2. Hide Clutter with a Menu Bar Manager

If you have a large collection of apps that need to stay running, use a dedicated manager to collapse them into a hidden drawer.

Ice (Free & Open Source): A modern, lightweight app designed specifically for macOS that lets you hide or show icons with a simple toggle arrow.
Hidden Bar (Free): An ultra-minimalist "collapsible drawer" tool. Hold Command (⌘) and drag low-priority icons behind the separator bar to tuck them out of sight.
Bartender (Paid): The gold standard. It creates a secondary "bar" completely underneath the main menu bar when you hover your mouse, ensuring zero icons are ever lost.

3. Tighten Icon Spacing via Terminal (No Apps Required)

Apple quietly increased the horizontal padding between menu bar icons in recent macOS versions, wasting valuable screen width. You can force macOS to tighten this spacing using two quick Terminal commands:

Open Terminal (Cmd + Space and type Terminal).
Paste this command and press Enter to shrink the icon containers:

defaults write com.apple.controlcenter "NSStatusItem2ExtensionMinPadding" -int 6

Paste this command and press Enter to reduce the gap between icons:

defaults write com.apple.controlcenter "NSStatusItemSpacing" -int 6

Apply the changes by restarting the control center:

killall ControlCenter

To revert to Apple's default airy spacing, run the same commands but change -int 6 to -int 12.

The 5-Second Emergency Fix

If an icon you desperately need right now is hidden behind the notch, don't panic. Go to System Settings > Displays and temporarily select "More Space" as your resolution. This shrinks the UI, expanding the menu bar text and forcing the hidden icons to pop out so you can click them.

Summary: What is the best solution?

For the cleanest setup, install Only Switch to consolidate your toggles, or use Ice to hide secondary icons. Combined with the Terminal spacing tweak, your MacBook notch will never block your workflow again.