Published on

My 2025 Big Changes: A Year of Transformation

2025 has been a year of profound transformation—not just in the tools I use, but in how I perceive computing, productivity, and the world itself. Three major changes reshaped my perspective: the journey into Linux, the evolution of AI-assisted development, and a philosophical awakening about the nature of coding. Each change built upon the previous, creating a coherent worldview that continues to guide my approach to technology and life.

The Linux Journey: Discovering "Less is More" 🐧

From Windows to Arch Linux

The transformation began in May 2025 when I made the leap to Arch Linux as my daily driver. What started as curiosity about a "lightweight, flexible Linux distro" evolved into a complete reimagining of my relationship with computers.

The initial motivation was practical: Windows felt increasingly opaque. Background services ran without clear purpose, indexing happened mysteriously, and default processes consumed resources for unknown reasons. As I documented in my Arch Linux journey, the question that haunted me was simple: "What is my computer doing when I'm not looking?"

Arch Linux answered that question with radical transparency. Every service running on my system exists because I explicitly installed and configured it. Every configuration file is readable, editable, and version-controlled. The system does exactly what I tell it to do—nothing more, nothing less.

The Philosophy of Operating Systems

Through this journey, I came to understand that operating systems embody different philosophies of human-computer interaction:

Windows represents the philosophy of "make it work for the masses"—a technical marvel of backward compatibility, but one that trades transparency for convenience. The open-source tools I relied on often struggled in this environment, and WSL, while helpful, meant running two different logic systems simultaneously.

macOS embodies "we know what's best for you"—elegant, polished, and genuinely excellent for specific tasks. But when I wanted to try a different approach that suited my specific needs, macOS simply didn't open that door.

Linux (Arch) declares "you can do it best in your own way." Yes, it requires time and energy—trying different software, writing custom logic, iterating until things work. But when everything finally runs according to your vision, it feels like you've created something rather than just used something existing.

The Terminal-First Workflow

The most significant shift was moving from GUI applications to terminal tools. My dotfiles repository tells the story: Fish shell for daily operations, River window manager for Wayland-native tiling, Qutebrowser for keyboard-driven web browsing, and Neovim for everything text-related.

This wasn't minimalism for its own sake—it was about unified logic control. By implementing VIM keymapping across my entire computing environment, I created a consistent muscle memory that extends from window management to coding to web browsing. One logic pattern controls everything:

  • Layer 1: River window manager with h/j/k/l navigation
  • Layer 2: Neovim for all text editing with modal operations
  • Layer 3: Qutebrowser with VIM-style link hinting and tab management

The result? Dramatically increased efficiency and a computing environment that truly reflects my thinking and workflow. "Less is more" became not just a slogan but a lived experience—fewer applications, fewer context switches, fewer distractions, more focus on actual work.

The AI-LLM Evolution: From Copilot to OpenCode đŸ€–

The Beginning: VSCode + GitHub Copilot

My AI-assisted coding journey began with GitHub Copilot in VSCode. Launched in public beta in 2021, Copilot initially functioned as a "smart code snippet generator." But by 2023-2024, with models like GPT-4 and the introduction of reasoning modules, AI's ability to understand and generate code improved dramatically.

The VSCode + Neovim + Copilot combination was my first serious AI-enhanced development environment. It combined VSCode's excellent ecosystem, Neovim's modal editing, and Copilot's intelligent suggestions. The setup worked well, but it was just the beginning.

The Claude Code Revolution

The real transformation came with Claude Code. Unlike Copilot's inline suggestions, Claude Code introduced agentic workflows—autonomous AI assistants that could analyze codebases, execute multi-step tasks, and integrate with external tools through the Model Context Protocol (MCP).

I built a complete configuration ecosystem with specialized agents:

  • Paper-Research Agent: Systematic academic paper discovery with quality verification
  • Blog-Writing Agent: Transform drafts into polished, publication-ready posts
  • Commit-Push Agent: Complete Git workflow with standardized commit messages
  • Weekly-Report-Writing Agent: Professional progress reports with academic language

The all-in-mcp server extended Claude Code's capabilities to academic databases like IACR and Google Scholar, making research workflows seamless.

But Claude Code had a critical limitation: vendor lock-in. If Anthropic changed its pricing or policies, my entire workflow would break.

The OpenCode Solution: Provider Independence

The solution came with OpenCode—an open-source AI coding CLI supporting 75+ LLM providers. The migration was straightforward: similar directory structure, compatible agent/command syntax, and identical MCP integration.

Now I can switch between providers based on task requirements:

  • DeepSeek for cost-effective daily coding (68x cheaper than Claude)
  • KIMI-K2 for complex reasoning with excellent context length
  • Qwen-Code for fast refactoring via Cerebras
  • GLM-4.6 for multilingual and coding tasks

This multi-provider approach optimizes for cost, speed, and capability at each step—no vendor lock-in, no single point of failure.

The Current State: NVIM + OpenCode

The evolution from VSCode+Copilot → Claude Code → NVIM+OpenCode represents a consistent trajectory toward simplicity and control. Each transition reduced dependencies while increasing capability:

  1. VSCode+Copilot: Full IDE with AI suggestions (heavy, vendor-locked)
  2. Claude Code: Agentic workflows with MCP integration (powerful, but Anthropic-dependent)
  3. NVIM+OpenCode: Terminal-native, provider-agnostic, fully customizable

The CodeCompanion plugin brings AI capabilities directly into Neovim with chat buffers, inline assistance, and agent workflows. Combined with OpenCode for complex tasks, I have a complete AI-assisted development environment that runs entirely in the terminal.

GitHub as Universal Context

A crucial insight emerged from this evolution: GitHub as the universal context layer. By tracking all my work through Git—code, configurations, notes, even this blog—I created a unified input format for AI-LLM agents.

The GitHub commit-diff URL becomes a standardized context that any AI tool can understand. Whether I'm using Claude Code, OpenCode, or a future tool that doesn't exist yet, the context remains consistent and portable. This approach embodies the "less is more" philosophy: one version control system, one context format, infinite AI tool compatibility.

Coding is Everything, Everything is Coding đŸ’»

The First Meaning: Coding as World Description

The phrase "coding is everything" captures my love for describing the world through rules and logic. Code represents order and predictability—a formal language for expressing how things work and how they should behave.

When I write a configuration file for River window manager, I'm not just setting up software—I'm encoding my preferences, workflows, and mental models into a precise, executable format. When I create an agent definition for Claude Code, I'm formalizing my understanding of how a task should be approached.

This perspective transforms coding from a technical skill into a way of thinking. Every system, every process, every workflow can be expressed as code—explicit, reproducible, and shareable.

The Second Meaning: Everything as Simulation

"Everything is coding" goes further: every system in the world can be understood, simulated, or explained through code. This isn't just a metaphor—it's a practical approach to understanding complexity.

In 2025, I began studying Abstract Algebra, which profoundly improved my abstract thinking ability. Abstract Algebra teaches you to see patterns across seemingly different structures—groups, rings, fields—and recognize that the same underlying logic applies to diverse phenomena.

This mathematical training reinforced my belief that coding is a universal language for understanding reality. Physical systems follow differential equations (code). Biological processes follow genetic algorithms (code). Social systems follow game-theoretic rules (code). Even human thought can be modeled as information processing (code).

The Synthesis: Order Through Abstraction

The three changes of 2025—Linux, AI tools, and this philosophical awakening—form a coherent whole:

Linux taught me that computing should be transparent, controllable, and minimal. Every component should serve a purpose, and I should understand how everything works.

AI-LLM evolution showed me that tools should be provider-agnostic, context-portable, and continuously improving. The best workflow is one that can adapt to new capabilities without losing accumulated knowledge.

"Coding is everything" provides the philosophical foundation: the world is comprehensible through formal systems, and the act of coding is the act of understanding and creating order.

Together, these insights point toward a unified approach: use simple, transparent tools to create formal descriptions of complex systems, leveraging AI to amplify human understanding and capability.

Looking Forward: 2026 and Beyond 🚀

As 2025 ends, I'm excited about where these trajectories lead:

  • AI tool evolution: Watching how multi-agent systems and reasoning models develop
  • Mathematical foundations: Continuing Abstract Algebra and exploring Category Theory
  • Knowledge systems: Building personal knowledge bases that integrate with AI workflows

The common thread? Increasing abstraction while maintaining control. Each layer of abstraction should make things simpler, not more complex. Each new tool should reduce dependencies, not create them. Each philosophical insight should clarify thinking, not obscure it.

2025 was transformative. Here's to more growth, more learning, and more adventures in 2026! 🎉

Related Posts 📚

Linux Journey:

AI-LLM Evolution: