SoylentNews

hubie [soylentnews.org] writes:

The Slow Death of the Power User [mataroa.blog]:

There's a certain kind of person who's becoming extinct. You've probably met one. Maybe you are one. Someone who actually understood the tools they used. Someone who could sit down at an unfamiliar system, poke at it for twenty minutes, and have a working mental model of what it was doing and why. Someone who read error messages instead of dismissing them. Someone who, when something broke, treated it as a puzzle rather than a betrayal.

That person is dying off. And nobody in the industry seems to care. In fact, most of them are actively celebrating the funeral while billing it as progress.

This isn't an accident. This is the result of two decades of deliberate, calculated effort by the largest technology companies on earth to turn users into consumers, instruments into appliances, and technical literacy into a niche hobby for weirdos. They succeeded beyond their wildest expectations. Congratulations to everyone involved. You've built a generation that can't extract a zip file without a dedicated app and calls it innovation.

The average person who grew up with smartphones has a fundamentally broken mental model of computing. Not broken in the sense that they can't operate their devices — they can, with terrifying efficiency. Broken in the sense that their understanding stops at the glass. They know how to use apps. They do not know what apps are. They know files exist somewhere, in the cloud maybe, or possibly inside the app itself — the distinction isn't clear to them and they've never needed it to be.

[...] Ask a twenty-two-year-old to connect to a remote server via SSH. Ask them to explain what DNS is at a conceptual level. Ask them to tell you the difference between their router's public IP and the local IP of their laptop. Ask them to open a terminal and list the contents of a directory. These are not advanced topics. Twenty years ago these were things you learned in the first week of any serious engagement with computers. Today they're exotic knowledge that even a lot of working software developers don't have, because you can go a long way in modern development without ever leaving the managed abstractions your platform provides.

And that's the real damage. It's not just end users who don't know this stuff. It's developers. People who write software for a living who've never had to think about what happens between their API call and the response. Who've never had to debug something at the network layer. Who've never had to read a full stack trace and understand every frame of it. Because the frameworks handle all of that, and the frameworks are good enough, and figuring out how things actually work is optional.

[...] The smartphone didn't just shift computing to a smaller screen. It replaced a computing paradigm — one built on ownership, modification, and composability — with a consumption paradigm built on managed access, curated experience, and dependency. And it did so with the full, deliberate, enthusiastic participation of every major platform vendor.

[...] All of this was sold as a feature. "It just works." Safety. Privacy. User experience. What it actually was, was control — Apple's control over what you could do with hardware you supposedly bought. And the genius move, the move that should make any serious observer furious, was convincing users that this control was being exercised on their behalf.

[...] Android played the same game with better PR. Google launched Android as an open platform, and for a few years it genuinely was. You could sideload APKs trivially. You could root your device and replace the entire OS. Manufacturers shipped custom builds. The ecosystem was messy and fragmented and occasionally awful and genuinely interesting. Then, gradually, systematically, Google started closing it down.

[...] The users who grew up on these platforms don't know what they're missing. They've never used a system where they were genuinely in control. The idea that you should be able to run arbitrary code on hardware you paid for is foreign to them — not rejected, but simply absent as a concept. They'll defend the restrictions without prompting because they've internalized the vendor's framing so thoroughly that they experience the cage as comfortable. "I don't want to root my phone, that sounds scary." Cool. You've successfully trained yourself to be afraid of ownership. The platform vendors are proud of you.

Technology culture used to celebrate technical competence. Not as gatekeeping, not as elitism — as genuine, infectious enthusiasm for understanding how systems worked. The BBS scene in the eighties ran on self-taught systems operators who understood their hardware and their network protocols well enough to build infrastructure that had never existed before. The early web had a "view source" ethos: you saw something interesting, you looked at how it was built, you learned from it, you made something of your own. [...]

These were not professional circles. You didn't need a CS degree. You needed curiosity and stubbornness and a tolerance for reading things that were too long and trying things that didn't work on the first ten attempts. The culture valued that and passed it down. Kids learned by watching, by lurking in forums, by getting their stupid questions answered by people who then expected them to answer someone else's stupid questions eventually. The knowledge propagated because the culture treated knowledge as worth propagating.

That culture didn't die because the knowledge became irrelevant. It died because it became economically inconvenient. The platforms that replaced the open internet — YouTube, Reddit, Discord, eventually TikTok — are consumption platforms. Their business model requires passive engagement. A user who spends three hours going down a documentation rabbit hole, breaking things in a terminal, and actually understanding something is worth less to them than a user who watches three hours of content. They don't ban technical material. They algorithmically deprioritize anything that demands active engagement, they reward passive consumption, and they shape the culture of their platform accordingly over years and years until the culture that emerges is one that treats passive consumption as the default relationship with technology.

[...] The man page is dead for most users. The RFC is unread by most developers who depend on the protocols it describes. Stack Overflow, which used to be a genuinely valuable resource for understanding why things behaved certain ways, has become a paste-and-pray operation: scan for a code snippet that looks related to your problem, copy it, run it, hope it works. When it doesn't, find another snippet. The understanding never enters the loop. LLMs have accelerated this to a degree that should make anyone who cares about software quality genuinely alarmed. You can now write complete programs without understanding what a single line of them does, and the programs will often work well enough in the happy path that you'll never know how thoroughly you don't understand what you've built until something goes wrong in production at two in the morning and you are completely without tools to respond.

This is what the culture has normalized: outcomes without understanding, solutions without models. And the response when you point this out is "okay but who has time for that," as if understanding were a productivity cost rather than the entire point.

The problem is not, primarily, that services collect data. The problem is that users have been convinced to treat pervasive surveillance infrastructure as benign or beneficial, and to respond to any criticism of it as paranoia, technical elitism, or failure to appreciate convenience. The learned helplessness is the crisis. The data collection is the symptom.

[...] The algorithm situation is the one that most directly affects daily life and receives the least serious scrutiny. Every major platform uses recommendation systems that are, in the most literal sense, making decisions about what information you encounter. What news exists in your world. Which of your friends' thoughts reach you. Which ideas get surfaced and which get buried. These systems are explicitly not neutral — they're optimized for engagement, which empirically correlates with outrage, anxiety, conflict, and tribal reinforcement, because those emotional states produce the behavioral signals the engagement metrics reward. The platforms are making your information diet worse on purpose, because worse converts to engagement, and engagement converts to revenue.

[...] We're losing the ability to audit. A person who understands their tools can notice when those tools start behaving badly. They can run a packet capture with tcpdump or Wireshark and see what their phone is actually transmitting. They can look at what their DNS resolver is returning. They can read the permissions an app requests and reason about whether those permissions make sense for what the app claims to do. They can notice when an update changes behavior in ways that benefit the developer at the user's expense. Most people have none of these capabilities and depend entirely on external review — journalists, academic security researchers, occasionally regulators — which is slow, incomplete, paid for by advertising revenue from the same companies being reviewed, and easily captured. [...]

We're losing resilience. Communities with high concentrations of technical competence can adapt when platforms change or die. They migrate. They self-host. They fork. When Google killed Reader, the technical community had self-hosted alternatives running within weeks. When Twitter's API became hostile to third-party clients, developers built ActivityPub implementations and federated alternatives. When a platform shifts its terms in ways that make it untenable, technically competent users can leave and rebuild elsewhere, carrying their data with them, because they understand their data as something they own rather than something that lives in the platform. Communities without those skills get stranded. [...]

We're losing the builder pipeline. This one compounds over time and the compounding is already visible. Power users become developers. Tinkerers become engineers. The kid who roots their Android phone and breaks it and fixes it and then writes a script to automate something the official interface doesn't support — that kid, ten years later, has intuitions about system behavior that you cannot get from a bootcamp and cannot get from building inside managed platforms your entire career. They know what it means when something is running slower than it should. They have hypotheses about failure modes before they start debugging because they've caused those failure modes themselves. They understand that abstractions are leaky and that the leak is usually where the interesting problems are.

Close off the tinkering and you close off the pipeline. What you get instead is a generation of developers who've only ever worked within platform constraints, who've never pushed against the edges of the abstractions they've been given, who treat framework behavior as ground truth rather than implementation detail. [...]

We're losing the adversarial capacity to hold platforms accountable. This is the one that matters most and gets talked about least. The open-source movement, the early security research community, the hacker culture in the original sense — these were not just about building things. They were a check on the power of institutions. [...]

[...] The industry isn't going to fix this. Every financial incentive points the other way. Confused, dependent users are more profitable than competent, autonomous ones. Lock-in is more valuable than interoperability. Opacity is more valuable than transparency. The architecture of modern consumer technology has been optimized against user competence with extraordinary success, and every quarterly earnings report validates the approach.

Regulators aren't going to fix it. They're fighting over app store fees while the underlying issue — the right of users to own and control the devices they've paid for — gets no serious legislative traction in most jurisdictions. The EU's Digital Markets Act has done some real work on interoperability requirements and is being fought by every affected platform with everything they have, because the platforms understand that the real threat is not the specific provisions but the principle that user autonomy is a value the law should protect.

Educators aren't going to fix it. Most digital literacy curricula teach application use. How to use Google Workspace. How to spot a phishing email. "Coding" in the form of block-based visual programming that produces no transferable understanding of how software actually works. The schools that teach real systems thinking, real network knowledge, real debugging skills — those schools cost money and are not where most people go.

The technical community is mostly not going to fix it either, because most of it has retreated into professional specialization and has largely given up on the broader project of maintaining technical literacy outside the profession. The open-source community does important work maintaining alternative infrastructure. It communicates almost entirely with itself.

So what's left is individual stubbornness. Which is not nothing. Organized individual stubbornness, pointed in the right direction, is how every important counter-cultural technical movement has worked.

Learn how your tools actually work. Not just how to operate them. Use the command line. Set up a home server and break it and fix it. Root a phone or, if you're on a platform where that's been made impossibly difficult, buy something where it isn't. Run a Linux install on bare metal and deal with the driver problems. Learn to read a network capture. Understand what your browser is sending with every request — the dev tools have been there the whole time. Host something yourself instead of using the managed service. Use open protocols where they exist: XMPP, ActivityPub, RSS, SMTP — these are old and unglamorous and they work and you own your data when you use them. Feed the federated alternatives even when they're worse than the centralized ones, because they're worse partly due to network effects and network effects respond to participation.

This is not about purity. Nobody is asking you to reject every managed service on principle or run Gentoo on everything. It's about maintaining enough technical competence that you are a participant in the systems you depend on rather than a permanent subject of them. It's about being able to make informed choices instead of having choices made for you by systems optimized for someone else's revenue.

The power user isn't dead. The skills exist. The communities exist — smaller, grayer, more scattered, fighting an institutional headwind that grows stronger every year. But they exist, and the knowledge is still propagating in the spaces the platforms haven't fully colonized.

The trajectory is bad. Every generation of new users arrives knowing less and expecting less. Every generation of new developers builds on more layers of managed abstraction and understands fewer of them. Every year it gets harder to explain why ownership matters, why understanding matters, why the convenience-for-control trade is a bad deal even when the convenience is genuinely excellent — because the people you're explaining it to have lived their entire lives inside the control and experienced it as freedom.

The obituary for the power user is being written right now. The people writing it are the same ones who sold you the phone, designed the app store, wrote the terms of service you didn't read, and built the algorithm that decided you didn't need to see this.

They are probably right about the timeline. They've been right about most things. The market has validated them at every step.

That is not an argument for giving up. It is an argument for being considerably angrier about it than most people currently are.

The full blog post is much longer and is a very interesting read.

Original Submission