The biggest productivity boost I've found isn't a single tool, but a curated stack that eliminates friction. As a full-stack developer running Anjeer Labs, my daily workflow depends on a few core tools that handle the mundane so I can focus on building. This isn't about trendy apps, but about what actually survives the grind of shipping real products.
Why I Switched to Warp as My Daily Terminal
For years, I used iTerm2 with zsh and Oh My Zsh. It worked, but configuration was a time sink. Warp is a modern, Rust-based terminal that changed my workflow. Its built-in AI command search is useful, but the real win is the blocks-based UI. Each command and its output live in a collapsible block, making it trivial to scroll back through a complex docker-compose or kubectl session. It has native autocomplete for Git and many CLI tools, reducing typos and recall time. It just reduces cognitive load.
# Traditional: Your whole scrollback is a flat stream.
# Warp: Commands and outputs are grouped visually.
[block: 10:24 AM]
$ git log --oneline -5
a1b2c3d (HEAD -> main) fix: resolve auth token expiry
e4f5g6h feat: add user dashboard endpoint
...
[block: 10:26 AM]
$ docker-compose up -d db
Creating network "app_default" with the default driver
Creating app_db_1 ... done
The visual separation and built-in workflows, like easily re-running a command from three blocks ago, have made it my default.
How I Use Cursor as More Than Just an Editor
I split my time between VS Code and Cursor. Cursor is an AI-first editor built on VS Code's engine. I don't use it to write entire features, but as a super-powered pair programmer for specific tasks. Its true value is in accelerating the boring parts: writing comprehensive unit tests, generating boilerplate for a new API route, or explaining a dense block of legacy code I didn't write.
// With a comment like this, Cursor's AI agent can generate the function:
// Create a utility function to safely parse JSON with a Zod schema, returning a Result type.
import { z, ZodError } from 'zod';
export function safeParse<T extends z.ZodTypeAny>(
schema: T,
jsonString: string
): { success: true; data: z.infer<T> } | { success: false; error: ZodError | Error } {
try {
const parsed = JSON.parse(jsonString);
const result = schema.safeParse(parsed);
if (result.success) {
return { success: true, data: result.data };
}
return { success: false, error: result.error };
} catch (err) {
return { success: false, error: err as Error };
}
}
It turns minutes of scaffolding into seconds. For pure editing and debugging, I often jump back to VS Code, but Cursor is indispensable for initial implementation and exploration.
Do You Really Need a Dedicated Database Client?
Yes, but not a heavy one. I've used TablePlus and DataGrip, but for 95% of my daily work, I now use Beekeeper Studio. It's fast, open-source, and does exactly what I need: connect to PostgreSQL, MySQL, or SQLite, run queries, and edit data. Its UI is clean and it doesn't try to do everything. For quick checks, schema explorations, and data fixes, a lightweight, dedicated tool is faster than any IDE plugin or CLI command. It keeps database work contained and efficient.
My Chrome Setup for Cutting Through Noise
A cluttered browser is a productivity killer. My Chrome is stripped down to a few key extensions: React Developer Tools, JSON Formatter, and the single most important one: uBlock Origin. Beyond blocking ads, I use its advanced mode to manually zap distracting page elements from sites I frequent, like trending sections on GitHub or YouTube. The second critical habit is using separate Chrome profiles—one for development (with all my dev extensions) and one for communication (Slack, Gmail). This creates a mental and performance boundary between building and managing.
The Single Most Important Tool: A Scripts Folder
No tool is more reliable than the scripts I write for myself. In every project, I have a /scripts directory. This is where I put the glue code that automates repetitive project-specific tasks: seeding a test database with realistic data, generating type definitions from an API spec, or deploying a preview build.
#!/usr/bin/env python3
# scripts/seed_demo.py
import psycopg2
import sys
sys.path.append('.')
from app.core.config import settings
conn = psycopg2.connect(settings.DATABASE_URL)
cur = conn.cursor()
# Insert demo users, projects, etc.
cur.execute("INSERT INTO users (email) VALUES (%s) ON CONFLICT DO NOTHING", ("demo@anjeerlabs.com",))
conn.commit()
print("Demo data seeded.")
These scripts compound time savings and are the first thing I document for any new team member.
The honest takeaway is this: your tools should feel like sharpened pencils, not novelty gadgets. If a tool requires more maintenance than the value it provides, cut it. The best tools silently disappear into your workflow.