What I use daily for development

By Pashalis Laoutaris | July 22, 2025 | Category: Developer Tools | 10 min read

Building an effective development environment isn’t just about collecting the latest tools—it’s about creating a cohesive ecosystem that enhances your productivity and supports your workflow. After years of experimentation and refinement, I’ve settled on a toolkit that strikes the right balance between functionality, performance, and ease of use.

In this article, I’ll share not just what I use, but more importantly, why I chose each tool and how they work together to create a seamless development experience. Whether you’re just starting out or looking to optimize your current setup, I hope these insights help you make more informed decisions about your own development environment.

My Development Philosophy

Before diving into specific tools, it’s worth understanding my approach to choosing development tools:

Prioritize open-source when possible: I prefer tools with active communities and transparent development
Focus on integration: Tools should work well together, not in isolation
Performance matters: Development tools shouldn’t slow me down
Extensibility is key: I need tools that can grow with my changing needs

With that foundation, let’s explore my daily drivers.

The Code Editor: VS Code

VS-Code UI

Why VS Code over other editors? After trying various editors over the years, VS Code won me over with its perfect balance of power and simplicity. It’s lightweight enough to start quickly, yet extensible enough to handle complex projects. The integrated terminal, Git support, and debugging capabilities mean I rarely need to leave the editor during development.

My Essential Extensions

Rather than listing every extension, here are the ones that fundamentally changed how I work:

GitHub Copilot has become my pair programming partner. It’s particularly valuable when working with unfamiliar APIs or when I need to write boilerplate code quickly. The key is learning to use it as a starting point rather than a final solution—I always review and refine its suggestions.

Tailwind CSS IntelliSense transforms the Tailwind development experience. Without it, you’re constantly referring to documentation. With it, you get instant class suggestions and CSS property previews, making it feel like you’re writing regular CSS with superpowers.

Pylance for Python development provides type checking and intelligent code completion that catches errors before you run your code. It’s especially valuable in larger Python projects where type hints become crucial for maintainability.

Pro-Tip: I’ve customized my VS Code with a unified color scheme across all file types and configured format-on-save for consistent code style. My settings sync across devices, so I get the same experience whether I’m on my laptop or desktop.

Version Control: Git for Windows

Why Git for Windows with BASH? While there are many Git GUIs available, I prefer the command line for its flexibility and universal availability. Git BASH provides a Unix-like environment on Windows, which is invaluable when working with deployment scripts or following tutorials written for Linux/Mac environments.

The command line also forces you to understand what Git is actually doing, making you a more effective developer when things go wrong (and they will).

Pro-Tip: I use aliases extensively to speed up common operations. git co for checkout, git br for branch, and git st for status save countless keystrokes over time.

Node.js Management: nvm

Why nvm over installing Node.js directly? Different projects often require different Node.js versions. Rather than constantly uninstalling and reinstalling Node.js, nvm allows me to switch versions instantly with a simple command. This is especially crucial when maintaining legacy projects alongside newer ones.

Pro-Tip: I keep a .nvmrc file in each project’s root directory specifying the required Node.js version. Running nvm use automatically switches to the correct version.

Databases: Choosing the Right Tool for the Job

Rather than having a one-size-fits-all approach, I choose databases based on project requirements:

Firebase: For Rapid Prototyping

I reach for Firebase when I need to validate an idea quickly. Its real-time database and built-in authentication mean I can have a functional backend in minutes. It’s perfect for hackathons or when building MVPs where speed to market matters more than cost optimization.

Use case example: I used Firebase for a real-time chat application where the built-in real-time listeners eliminated the need for complex WebSocket management.

Supabase: For PostgreSQL Power with Firebase Convenience

When I need the flexibility of a relational database but still want the convenience of a backend-as-a-service, Supabase is my go-to. The ability to write complex SQL queries while having instant APIs generated is incredibly powerful.

Use case example: For a project management tool, I needed complex relationships between users, projects, and tasks. Supabase’s PostgreSQL foundation handled the relational complexity while its auto-generated APIs saved development time.

Turso: For Edge Computing

For applications where latency matters and I need global distribution, Turso’s SQLite-based distributed database provides the familiar SQL interface with edge performance.

Building Modern Web Applications: The Astro Stack

Astro Project Setup

My current go-to stack for content-focused websites centers around Astro, and here’s why this combination works so well:

Astro: The Islands Architecture Advantage

Why Astro over Next.js or Gatsby? Astro’s “islands architecture” solves a problem I’ve encountered with other frameworks: JavaScript bloat. With Astro, I can build primarily static sites but add interactive islands exactly where needed. This results in faster loading times and better SEO performance.

For my personal blog, this means the article content loads instantly as static HTML, but I can still have an interactive comment section or search functionality where needed.

Tailwind CSS: Utility-First Styling

Why Tailwind over traditional CSS? After years of wrestling with CSS architectures and naming conventions, Tailwind’s utility-first approach eliminated decision fatigue. Instead of wondering “what should I call this component?” or “where should this style live?”, I can focus on the design itself.

Pro-Tip: I use Tailwind’s @apply directive sparingly, only for frequently repeated utility combinations. This keeps the benefits of utility classes while avoiding repetition.

The Supporting Cast

Sharp handles image optimization automatically, converting and resizing images for different screen sizes
TypeScript catches errors before they reach production, which is especially valuable in larger projects
Astro SEO ensures proper meta tags and structured data without manual configuration

Deployment and Hosting: The Cloudflare Ecosystem

Why Cloudflare over Vercel or Netlify? While all three are excellent platforms, Cloudflare’s integrated approach appeals to me. I can manage domains, DNS, static hosting (Pages), and serverless functions (Workers) all in one place. The global CDN and DDoS protection are bonuses.

GitHub Actions handles my CI/CD pipeline, automatically deploying to Cloudflare Pages when I push to the main branch. This automation means I can focus on coding rather than deployment logistics.

Hardware: Optimizing for Different Contexts

Primary Laptop: Lenovo LOQ 16IRH8

Lenovo LOQ 16IRH8

Component	Specification	Why This Matters
CPU	Intel Core I7 13620H	Handles large builds and compilation
RAM	16GB DDR5	Smooth multitasking with IDEs, browsers, and local servers
Storage	1TB M2 NVMe PCIe 4	Fast project loading and file operations
GPU	Nvidia RTX 4050	Occasional ML experiments and smooth UI rendering
Display	16” 144Hz, 1920 x 1200	High refresh rate reduces eye strain during long coding sessions

Why I chose this model: After using a lower-powered laptop for years, the performance difference is substantial. Large Node.js builds that took minutes now complete in seconds. The 16GB RAM allows me to run multiple development servers simultaneously without slowdowns.

Pro-Tip: The 144Hz display might seem like overkill for development, but the smoother scrolling and reduced motion blur genuinely reduce eye fatigue during long coding sessions.

Desktop: The Reliable Workhorse

Samsung M5 32"

Component	Specification	Role in My Workflow
CPU	Intel i7 6700K	Still handles most development tasks well
Storage	512GB & 1TB SSD SATA	Separate drives for OS and projects
Display	27” & 32” Samsung Monitors	Dual monitor setup for productivity

While older, this desktop still serves specific purposes:

Testing environment: Different hardware helps catch performance issues
Always-on development server: Runs local databases and services
Backup workspace: When my laptop needs maintenance

The dual monitor advantage: One screen for code, another for documentation, browser testing, or terminal output. Once you’ve experienced this workflow, single-screen development feels limiting.

General Tools: Beyond Development

GIMP: Open-Source Image Editing

While not primarily a development tool, GIMP handles all my image processing needs for web projects. I use it to optimize images, create favicons, and design simple graphics.

Pro-Tip: I’ve created custom scripts to automatically export images in multiple formats (WebP, PNG, JPEG) and sizes for responsive web images.

Obsidian: Knowledge Management

Development involves constant learning, and Obsidian helps me build connections between concepts. I use it to document architectural decisions, keep notes on new technologies, and maintain a personal knowledge base.

Brave Browser: Privacy-Focused Development

For general browsing and testing, Brave provides a good balance of privacy and compatibility. Its built-in ad blocker means faster page loads when researching documentation.

My Development Workflow in Action

Here’s how these tools work together in a typical project:

Planning: Ideas and architecture notes go into Obsidian
Setup: Clone repository, run nvm use to switch to the correct Node.js version
Development: Code in VS Code with live preview in Brave browser
Version Control: Commit changes using Git BASH with custom aliases
Testing: Use different browsers and the desktop setup for cross-platform testing
Deployment: Push to GitHub, GitHub Actions handles the build and deployment to Cloudflare Pages
Monitoring: Cloudflare’s analytics show performance and usage metrics

Key Takeaways

After years of tool experimentation, here are the most important lessons I’ve learned:

Integration matters more than individual tool perfection: A good tool that works well with your other tools is better than a perfect tool that doesn’t
Automate repetitive tasks: Whether it’s deployment, image optimization, or environment setup, automation pays dividends
Performance compounds: Small performance improvements in your tools add up to significant productivity gains
Don’t over-optimize: Sometimes the default configuration is good enough; focus your customization energy where it has the biggest impact

What’s Next?

I’m currently exploring:

Containerization with Docker: For more consistent development environments
AI-powered testing tools: To automate more of the QA process
Edge computing: Experimenting with Cloudflare Workers for dynamic functionality

What tools are essential to your development workflow? I’d love to hear about your setup and any tools I might be missing. Feel free to share your favorites in the comments below—the best development environments are built on shared knowledge and continuous experimentation.