Software used to show up finished. A company decided what it could do, you learned its menus and put up with its limits, and if you wanted something changed, you waited for a roadmap, an engineering team, and a release.
That arrangement is starting to crack.
DeepSeek says its Harness agent platform hit 1.54 million daily active users by November 4. It reports about 35,000 third-party plugins, and roughly 60% of active users have built or installed at least one. Those numbers are self-reported and only cover people using the official API, so I wouldn’t treat them as gospel. But the shift underneath them matters more than the exact figures: ordinary people are starting to put together their own software.
This isn’t just another app-store story. It’s a change in who gets to decide what software is. That used to be a small group of product managers and engineers. Now it’s also the researcher, the freelancer, and the shop owner who can explain what they need and then build it.
From using software to composing it
For most of computing history, software was something you bought. You learned the interface and hoped the vendor would eventually add the feature you wanted.
Then came configuration: settings, templates, integrations, no-code tools. That gave users more say, but always inside boundaries someone else drew.
Agent platforms go a step further. Instead of tweaking an app, you can combine models, tools, memory, storage, and automations into a system built for one specific job. DeepSeek describes Harness as a runtime made of swappable plugins, and its docs say things like search, memory, vision, terminal access, and notifications are mostly plugin-based.
So the unit of software is changing. It’s less about the application now and more about the workflow, the chain of steps that turns a vague human intention into a finished task.
Picture a researcher who links literature search, reference management, translation, and note-taking into a personal assistant. Or a salesperson who strings together CRM lookups, email drafts, meeting notes, and follow-up reminders. Or a small-business owner who sets up intake, invoicing, and customer replies without hiring a developer.
What you use is no longer only what the vendor ships. It’s also what you assemble yourself.
The 60% signal
The 35,000 plugins figure sounds big, but it’s not the interesting one. The 60% is.
If about six in ten active users have built or installed a plugin, extending the platform is turning into ordinary behavior rather than a niche hobby for developers.
Here’s how I read the numbers. The 1.54 million daily users suggest agent platforms can reach real scale. The 35,000 plugins point to a creator ecosystem forming around the platform. The 60% suggests many people are customizing and building, not just consuming. And DeepSeek’s planned official marketplace, with discovery, distribution, compatibility checks, and creator incentives, shows the company knows it.
Again, the caveat: nobody has independently audited these figures. Take them as a sign of momentum, not a census. Even so, if the real participation rate is lower than claimed, the direction still holds. A meaningful group of users has stopped waiting for someone else to build the missing piece.
Users become agent architects
The most interesting part of this isn’t technical. It’s social.
A new kind of builder is showing up, and I’d call them an agent architect. They may not write production code or manage servers. But they know their field well enough to spell out a workflow, pick the right tools, set limits, and tell whether the result is any good.
That’s a different kind of technical skill. Take a marketing manager who wants customer feedback turned into weekly reports. In the old world, she files a ticket and waits. In this one, she describes the workflow, picks tools, tests the output, tweaks the instructions, and shares the result with her team.
The expertise sits closer to the problem. A lawyer, teacher, nurse, accountant, or operations lead can capture some of what they know in a reusable system. They don’t have to become programmers, but they do have to learn a new craft: stating goals clearly, deciding what data a tool can touch, testing how it fails, and keeping their own judgment in the loop.
This is why “non-technical user” is getting harder to defend as a category. The real question isn’t whether someone can code. It’s whether they can design a workflow that works reliably.
Why the barrier collapsed
A few things happened at once.
Natural language became an interface, so you can describe what you want in plain words instead of translating it into code. Agents now handle much of the glue work, like drafting logic, calling tools, formatting data, and retrying failed steps. Components are composable, so you can remix what exists instead of starting from scratch. Sharing is easy, so a plugin built for one person’s workflow can be adapted by hundreds of others. And you can test an idea in minutes rather than wait weeks for a release.
DeepSeek’s documentation backs this up with real plumbing: a make-dsh-plugin bootstrap skill, plugin manifests, several installation methods, and a panel for enabling, disabling, updating, and removing plugins. That kind of support is what turns “you could build a plugin” into “here’s how you build one.”
Programming is becoming conversational, and distribution is becoming social.
What gets bypassed
None of this means software engineering is going away. It means that for a growing class of small, personal, domain-specific automations, big chunks of the traditional pipeline get skipped.
Normally a product manager spots a need, engineers scope and build it, QA and release cycles follow, and the vendor owns the roadmap. In the plugin model, the user hits the need while doing real work, assembles or describes the fix, iterates quickly, and shares it. The roadmap gets shaped by users and creators, and the software behaves less like a finished product and more like a living ecosystem.
That’s powerful. Useful tools can grow out of actual work rather than a central guess about what people want.
But skipping the pipeline also skips some of its safeguards. A plugin that touches your email, files, contacts, or the network can do real damage. DeepSeek’s own docs tell users to read a third-party plugin’s source and check its permissions before installing it, especially if it can make outbound network connections.
Making creation open to everyone doesn’t automatically make trust open to everyone.
The people’s app store
DeepSeek plans an official marketplace for publishing and finding plugins. It’s also promising better API stability, compatibility, and security, plus a creator program with token incentives, technical exchanges, and featured projects.
A marketplace could become the institutional backbone of this ecosystem. It brings discovery, reputation, review, permissions, payments, moderation, and versioning. It can help a good plugin find its audience. It also hands the platform operator a lot of power over what gets seen, rewarded, and kept alive.
So the real question is whether this “people’s app store” stays open. If creators can publish, modify, export, and earn from their work freely, it could become something like a distributed product organization. If discovery and incentives get tightly controlled, it could end up as another walled garden with a friendlier face.
The plugin count won’t settle that. The marketplace rules will.
The risks of everyone building
A world where anyone can build software is exciting, and it comes with its own ways of going wrong.
Security is the obvious one. Plugins with broad permissions are attack surfaces, especially when they connect to private data, messaging, or outside services. Quality is another. A big plugin count says nothing about whether the plugins are safe, useful, or maintained, and DeepSeek itself admits community plugins vary in maturity. Then there’s fragmentation: thousands of small tools may behave differently across versions and setups. Accountability gets murky too. If an agent does something harmful, is it the model provider, the plugin author, the platform, or the user who’s responsible? And there’s dependency, since people can get locked into one platform’s APIs, marketplace rules, and incentives.
So the platform’s job isn’t just to make building easy. It’s to make building safe, understandable, reversible, and financially sustainable.
What software companies should do
For product leaders, the lesson isn’t “bolt on a chatbot.” It’s to rethink the product around extensibility.
That means giving users places to add capabilities without waiting for a release, and setting safe defaults like permissions, sandboxing, audit logs, and easy rollback. It means letting people export and reuse what they make, so they own their workflows. It means paying creators, because valuable plugins shouldn’t run on unpaid enthusiasm alone. And it means building trust infrastructure: review, security scanning, compatibility testing, and clear accountability.
The winners may not be the companies with the slickest features. They may be the ones that turn their users into the most capable builders.
What it means for work
For workers, the message is just as direct. Domain expertise gets more valuable, not less. Someone who understands compliance, patient care, supply chains, classrooms, or sales can turn that understanding into an automated workflow.
But the scarce skill is shifting. It’s less about writing every line of code and more about stating outcomes clearly, setting guardrails, choosing trustworthy tools and data, testing edge cases, reviewing what the automation produces, and knowing when not to automate at all.
The people who’ll do best are the ones who can pair domain judgment with agent design.
Is this really “software forever”?
Skeptics have a point. Plugin ecosystems aren’t new. Browser extensions, spreadsheet macros, app stores, and no-code platforms have all promised to turn users into builders.
What’s different this time is how much friction has been removed. Earlier tools let you configure software. Agent platforms let you describe a system, generate it, connect it, and keep refining it. The change isn’t just that you can install add-ons. It’s that you can build semi-autonomous systems around your own work.
Whether that lasts depends on reliability, security, the economics, and whether platforms let people actually own what they build.
The new social contract
The most important product of the agent era might not be a smarter model. It might be a platform that turns ordinary people into builders of their own software.
DeepSeek’s reported numbers, 35,000 third-party plugins, 60% participation among active users, and a marketplace on the way, are an early sign of that possibility. They describe a platform trying to make creation part of everyday use.
If it works, software will feel less like a product you buy and more like a language you speak, one that more people can use to shape their own tools and their own working lives.