My setup I never thought would be so productive

Datanarch by HP • • 6 min read
linuxproductivitydevelopment setupterminalworkflow

After 15 years using Windows as my main operating system, I made the jump to Linux. It wasn’t a purely technical decision — it was a need for efficiency that completely changed the way I work.

This is the setup that allows me to be productive as a solo developer, focusing on solving real problems instead of fighting with my work environment.

The change: Windows → Linux

For a long time, I had wanted to get the most out of the operating system. RAM memory (I currently have 16gb) was always the main problem: unsustainable excessive consumption; after some time, the slowness with which the operating system behaved became unmanageable.

After thinking about it a lot and seeing my possibilities of changing the hardware, I had no other option but to give the operating system that has called my attention for a long time (I had experience managing it previously with several VMs on AWS) a chance, but now for greater purposes, using it in my daily work (Solo Developer).

The change to Ubuntu has been very smooth, due to the parity it has with Windows, but at first it was a bit uphill. I use a lot of shortcuts that were currently not found in the same way or with the same ease.

Making the transition to open source, I couldn’t get the same product, or with the same finishes, but it did have the same qualities.

From my mental shift: “Don’t look for the same product, look for the most viable and possible solution”. This change made me understand that the open source world was a whole labyrinth, and at the same time a universe of customizations, forgetting the details, I could obtain the same reliability at the cost of learning and evolving together with my productivity.

My experience: I never thought that by just making the switch to Linux I could revolutionize my productivity, be more efficient, love the process more without waiting for the result.

Minimalist hardware: Linux doesn’t need brute power

One of the biggest revelations: you don’t need a latest generation machine.

My current hardware

Laptop with external monitor - development setup

  • Monitor(s):

  • CRUA 27’ CRUA 27 inch monitor


  • Dell 23’ Dell 23 inch monitor

  • Peripherals:


Mouse:
Wireless mouse

And regarding the keyboard, I like to use the laptop’s built-in keyboard, simple, ergonomic and quite quiet.

Why does it work?

Linux is incredibly efficient:

  • Less operating system overhead
  • No unnecessary background processes
  • Total control over what runs and when
  • Updates that don’t interrupt you

The terminal: Why did I stop clicking?

This was the most transformative change. The terminal isn’t just “faster” — it’s fundamentally superior for development.

Command line advantages

Speed:

# GUI: Open app → Find folder → Click → Click → Click
# Terminal:
cd project && code .

Reproducibility: Every command can be documented, shared and automated.

Composability:

# Find Python files modified today and count lines
find . -name "*.py" -mtime -1 | xargs wc -l

Power:

  • Instant batch operations
  • Text manipulation with sed/awk/grep
  • Scripts that automate repetitive tasks
  • Total system control

My shell: zsh

Personalized configuration:

  • Aliases I use daily
  • Custom functions for common tasks
  • Informative but minimalist prompt

Essential setup tools

My stack is intentionally simple. Each tool has a clear purpose.

1. GitHub: Beyond git

Not just version control:

  • gh CLI for PRs and issues
  • GitHub Actions for CI/CD
  • Project and task management
  • Centralized documentation

Commands I use daily:

gh repo clone user/repo
gh pr create
gh issue list

2. VS Code: The versatile editor

My key Extensions:

  • AutoDocstring
  • AWS toolkit (also in the shell with the native SDK)
  • Astro (for this blog/journal)
  • JavaScript and TypeScript nightly
  • ES7 + React/Redux/React-Native
  • Highlight Matching Tag (important when there are many tags in development)
  • Import Cost (I like to be efficient when importing)

Why VS Code?

  • Perfect balance between simplicity and power
  • Excellent terminal integration
  • Remote development
  • Infinite extensibility

3. Claude/ChatGPT: Learning copilot

This deserves special attention. I don’t use them to “magically generate code”, I use them for:

Accelerated learning:

  • Explanations of complex concepts
  • Understanding legacy code
  • Exploring new technologies
  • Debugging obscure problems
  • Code review / Learning about best practices

Real productivity:

  • Generate quick boilerplate
  • Refactoring suggestions
  • Automatic documentation
  • Virtual pair programming

“As a solo developer, Claude is my intelligent rubber duck”

My workflow with AI:

  1. Understand the business problem
  2. Design the solution
  3. Use AI to accelerate implementation
  4. Review, adapt and manage the generated code
  5. Learn from the process

4. My personal library: Curated knowledge

Technical books aren’t decoration — they’re active references.

My constant references:

  1. The Essential Data Warehouse library - For everything related to data warehouse.
  2. Streaming Systems - For everything that refers to streaming processes
  3. Data Management at Scale - For all information team management
  4. Programming Scala - For everything involving programming with scala
  5. Introduction to Data Mining - For data mining processes
  6. Think Bayes - My reference source for python and bayesian thinking
  7. Programming Typescript - For all the little details that are always forgotten in typescript
  8. Effective TypeScript - My reference source on advanced typescript topics
  9. Design Patterns: Elements of Reusable Object-Oriented Software - The bible of design patterns for object-oriented programming. among others…

How I use them:

  • Quick concept lookup
  • Deep dive when Stack Overflow isn’t enough
  • Fundamentals that don’t change with trends
  • Validated expert perspectives

Markdown: My organizational nervous system

.md files for EVERYTHING:

Task lists

## Current Sprint
- [ ] Feature X
- [ ] Bug fix Y
- [x] Refactor Z

Technical documentation

# Project XYZ

## Architecture
- Diagram
- Technical decisions

## Setup
- Installation steps
- Environment variables

Meeting notes

# Client Meeting - 2024-10-13
- Identified problem
- Proposed solution
- Next steps

Personal knowledge base

# How to do X in Python
# Error Y and its solution
# Patterns that work

Advantages:

  • Versionable with Git
  • Readable in any editor
  • Exportable to any format
  • Searchable with grep

Philosophy: Efficiency over ease

This is the core of my productivity.

Understand the business problem first

Before writing code:

  1. What problem does this solve?
  2. For whom?
  3. How is success measured?
  4. What is the real MVP?

“The best line of code is the one you don’t have to write”

Efficient solution ≠ Easy solution

Easy: Use framework X because everyone uses it Efficient: Evaluate if you need framework or vanilla is enough

Easy: Copy-paste from Stack Overflow Efficient: Understand the why and adapt

Easy: Add dependency for everything Efficient: Write 10 lines of your own when it makes sense

Creative constraints

Linux forced me to:

  • Think before installing
  • Understand what each command does
  • Depend less on GUIs
  • Automate the repetitive

These “limits” made me a better developer.

How this makes me productive as a solo developer

Advantages of my setup:

1. Quick start From shutdown to writing code: < 3 minutes

2. No distractions

  • Terminal = focus
  • No invasive notifications
  • Total control of environment

3. Reproducible All my setup is in dotfiles:

git clone my-dotfiles
./install.sh
# Done

4. Scalable Tools grow with me:

  • Scripts become more sophisticated
  • Aliases evolve
  • Workflow constantly optimizes

Challenges and trade-offs

Learning curve:

  • First weeks are tough
  • Requires discipline
  • Not everything has GUI

Maintenance:

  • You are your own IT support
  • Troubleshooting requires knowledge
  • Updates occasionally break things

Is it worth it? Absolutely.

Conclusion: Intentional productivity

My productive setup isn’t the most common or the “coolest”. It’s intentional.

Each tool has a reason to exist:

  • Linux: efficiency and control
  • Terminal: speed and power
  • Markdown: simplicity and portability
  • AI: accelerated learning
  • Books: solid foundations

The setup doesn’t make you productive — your decisions do.

My productivity doesn’t come from hardware or tools. It comes from:

  1. Understanding problems before solving them
  2. Choosing efficiency over convenience
  3. Learning constantly
  4. Automating the repetitive
  5. Documenting everything
  6. Maintaining a positive attitude towards the unknown

What’s your setup? What tools do you consider essential? I’d love to know your workflow.

Mentioned resources:

Connect with me: