I Spent Months Coding on Android. It Changed How I Think.

When people think about software development, they almost instinctively picture a laptop. It doesn't really matter whether it's running Linux, macOS, or Windows—there's an expectation that serious engineering belongs on a traditional computer. Android, on the other hand, is usually treated as a device for consuming content. It's where we reply to messages, browse the web, watch videos, or occasionally make small edits to a document. The idea of building production software on it still sounds unusual to many developers.

For a long time, I shared that assumption.

I didn't start this experiment because I wanted to prove that Android could replace a laptop. In fact, I wasn't trying to prove anything at all. I was simply curious about how far I could push the device that I already carried with me every day. What began as installing a terminal emulator eventually turned into running full development environments, working on real projects, and gradually moving more of my daily workflow onto Android. Somewhere along the way, it stopped feeling like an experiment and started feeling surprisingly normal.

That transition was the most unexpected part.

Most discussions about Android as a development platform immediately jump to its limitations. People ask whether it can run a specific tool, whether it supports a particular framework, or whether some feature is missing. Those are reasonable questions, but they also miss something more interesting. Before I encountered any serious limitations, I found myself spending hours writing code without thinking much about the operating system underneath. Git worked exactly the way I expected. SSH sessions felt no different from those on a desktop. Modern programming languages and their toolchains have become increasingly portable, and many JavaScript, Rust, Go, Java, and Python projects simply ran without requiring much adaptation.

The experience made me realize how much software development has changed over the past decade. We often talk about programming languages evolving or frameworks becoming more capable, but our assumptions about the computers we use have changed just as dramatically. A modern development environment is no longer tied to a specific architecture or even a specific operating system. As long as the essential tools are available, much of the workflow feels remarkably familiar regardless of the device sitting in front of you.

Of course, Android isn't identical to a traditional Linux distribution, and pretending otherwise would ignore some very real differences. The limitations don't usually appear when you create a new project or write your first few hundred lines of code. They tend to emerge gradually as projects become larger and development tools become more sophisticated. Certain filesystem behaviors differ from what many tools expect. File watching can occasionally become unreliable. Some newer build systems and development servers assume an environment that looks much more like a conventional desktop Linux installation. None of these issues make development impossible, but together they remind you that Android still occupies an unusual place in the software ecosystem.

Interestingly, those moments never convinced me that Android was the wrong platform. Instead, they highlighted how many assumptions modern developer tools quietly make about the environments they're built for. We often describe software as being "cross-platform," but many projects are really designed around a relatively narrow definition of what a computer looks like. Android happens to be compatible enough that most things work, yet different enough to expose assumptions that usually remain invisible on desktop operating systems.

As I spent more time developing this way, I noticed another shift that had nothing to do with Android itself. I stopped thinking of my development machine as a single physical computer. Sometimes I was writing code directly on the device. Sometimes I was connected to another machine over SSH. Other times I was using a cloud-based environment. The boundaries between local and remote development became increasingly blurred, and Android naturally fit into that workflow. It wasn't replacing every computer I owned—it was becoming another endpoint through which I could access my projects.

Looking back, I think the most valuable lesson wasn't that Android is capable of software development. That's simply a technical fact. The more interesting realization is that our definition of a development computer may already be outdated. We still tend to imagine a powerful laptop as the center of everything we do, even though many modern workflows are distributed across local devices, remote servers, cloud environments, and web-based tools. Once you begin thinking that way, the operating system in your hands becomes less important than the environment you're able to build around it.

I'm not arguing that everyone should start developing on Android. For many people, a traditional laptop will remain the most practical choice, and there are still workflows that Android cannot support as comfortably. But I do think the platform deserves to be taken more seriously than it usually is. The conversation shouldn't be limited to whether Android can replace Linux or macOS. A more interesting question is why we continue to assume that software development belongs exclusively on those platforms in the first place.

Several years ago, the idea of building a serious application on an Android device would have sounded unrealistic. Today, I think it's simply unconventional. Those are very different things, and the gap between them continues to shrink.

Perhaps that's the real story. Android didn't replace my idea of what a computer should be. It forced me to reconsider whether that idea was ever as fixed as I believed.