A Product in 3 Days with AI: Why Selling Software Is Hard

Why “A Product in Three Days”? Because that’s roughly how long it takes these days to build a working, complete product. Something you can already show people and that could realistically be worth paying for.

Just a few years ago, this was a pipe dream. Today AI models are so strong that they can handle almost any programming task. A complex script, a rewritten program or a whole service can be done in a day. The remaining couple of days go into polishing, so everything actually works the way it should.

Sounds like great news for anyone who wants to make money from their own software. But there’s a paradox here: building a program has become easy, while turning it into a successful product and selling it is as hard as ever. And that hits hardest the people who plan to sell software at a high price.

Simple products like scripts sometimes take me about three hours, plus a few more hours of polishing. That’s how I made Height Map Studio, for example: it creates Normal, Displace, AO and Specular maps from a single texture right inside 3ds Max.

I described the task, and from the very first prompt the script already did what I needed. After that I refined it: I removed unnecessary options, added a few key features that help make better maps, and sped up the algorithm so it runs instantly.

That’s it, the product is done. If I’d built a script like this before AI, figuring out all these technologies on my own, it would have taken me half a year, maybe more.

Codex and Claude Code are completely changing how software gets built. What used to take years can now be done in a few weeks or a month.

For example, I built the MaxPkg website in a few months. I didn’t understand every technology it uses, I just gave the right prompts. The result was a website, a separate manager and a separate packager. In other words, a whole service plus a few products around it.

That site also has plenty of my other scripts that were made in a matter of hours. Max Rewind, on the other hand, took about three days. It’s a genuinely complex product with lots of options and a ton of under-the-hood work to make everything run as fast as possible. And tools like this sell for good money, say 100 or even 200 dollars per license.

One more observation. Not long ago, even simple things with agents required complex prompts, upfront planning and so on. Now the models are much smarter, and a couple of words get you a far better result.

And this is where the main problem starts. There have already been news stories about developers building a Photoshop clone, an almost one-to-one Figma clone and even a 3ds Max clone (based on Blender). Products that took decades to build can now be recreated fairly quickly, at least at the level of their core features. Sure, that’s not a full replacement for the original yet, but for many users it may already be enough.

High prices used to be justified by the fact that development was long and expensive, and there were hardly any alternatives. Now development is getting cheaper, and with it, what buyers are willing to pay is changing too. What I’m getting at is that selling software the old way, at a high price, is getting harder and harder. If you plan to build a product and slap a big price tag on it, be ready for this: people may find it easier to build the tool they need themselves and have it work exactly the way they want.

Here's an example from my own life. I work on macOS a lot, and I like switching input languages with dedicated shortcuts: Ctrl+1, Ctrl+2, Ctrl+3. Each combination has its own language, so I always know exactly which one is active. Windows has long let you assign a separate shortcut to a specific language, and it works great. macOS just didn't have that option.

So I had to install some weird program with a pile of features. If you manually tweaked its configuration just right, you could eventually get the switching you wanted. But honestly, it worked so-so.

So I made my own utility that does only these operations and nothing else. You launch it, and it just works. It uses less RAM, and the hotkeys don’t break the way they did with the old program.

That’s my point: these days it’s easier to write your own than to figure out someone else’s.

I built CoverForge in three days too. Let me be clear right away: it’s not an attempt to replace four big programs, but my own tool that has only what I need for making covers.

From each program I took what I actually needed: the precision of Figma with its Auto Layout and snapping, the nice effects of Photoshop, 3D text from Canva, and filters from Instagram.

I put all of that into one program. No extra features, no useless buttons: every tool sits where it should, and everything is clear and easy to use. I also plugged in local AI models that enhance and automatically retouch faces, and match colors so everything blends into the surroundings.

So even a complex graphics editor built for your own needs is no longer a problem. The hard stuff has become simple.

There’s another thing I keep seeing. People buy a subscription and immediately start building the app of their dreams. They burn through a ton of tokens, some spend weeks on it, and they end up with a genuinely decent program. Then they ask me the same questions: how do I monetize this, how do I add payments, how do I protect the program, how do I issue licenses, how do I set up a subscription?

It makes total sense. You spent your time and want to get it back as money. The problem is that without experience in marketing and UI/UX design, and without understanding how a product is actually created and promoted, you won’t be able to sell it properly. You might get a few sales, but real success is hard to reach. And all of that will take more time than the development itself.

I’d say that when you create and launch a commercial product, programming is about 30 % of the whole job, and now that everything has sped up, maybe even less. Everything else is built around the product:

• a domain name;
• reputation;
• a website;
• videos;
• social media posts;
• registering a company to get a VAT number;
• setting up a good payment system like Stripe.

And even if you do all of that, nobody guarantees success. People might simply not like it, or find it inconvenient. Also keep in mind: if you set a high price, it’s easier to buy a subscription to Claude Code and build the same product yourself in a week. That works out cheaper.

My main message is this: if you’re already building a product, don’t put a big price on it. Models will keep getting smarter, development will get easier, and eventually you’ll be able to build programs without any special knowledge. I think prices for this kind of software will keep dropping. So it’s better to set a price the buyer can’t refuse right from the start. One that makes buying easier than building the same thing from scratch.

That said, people will still pay for good products. Just not so much for the features as for convenience: the program runs reliably, gets regular updates, has support, doesn’t need any setup and saves time. Even if someone could write their own Photoshop alternative, buying a ready-made, reliable solution will often be easier.

The uniqueness of the idea matters too. If your product has plenty of alternatives, nobody is going to go to a developer who signed up today, launched a website yesterday and has no reputation yet.

By the way, reputation is a whole separate story. A guy once reached out to me who was building a pretty decent product. He showed me how it worked, and the idea really was cool. But I checked his app on VirusTotal, and it found viruses.

I doubt he did it on purpose. Most likely it was a false positive: some antivirus engines may have flagged the program’s network connections or other aspects of how it works as suspicious. But even one red line on VirusTotal tells users they’d better not touch it. And that hits your reputation really hard.

Reputation is very hard to earn and very easy to lose. That’s why everything around the product needs to be worked out very carefully, with a clear plan of what to do and how.

But even if you’ve gone through all these stages, setting up payments is pretty tricky. You need a good provider that looks reliable and earns trust. Again, that’s your reputation. If a dispute comes up, you should be able to refund the money in full, without any fees withheld. Otherwise you’ll get plenty of unhappy customers writing angry comments about you on social media.

And then there are payment systems where a payment takes several hours to go through. So someone has paid but doesn’t get what they bought right away. In those couple of hours you can get dozens of emails along the lines of “where’s my product?” and “give me my money back”. That happened to me with 2Checkout, and I really don’t recommend that system.

I also often see products being built without backups and without version control. As a result, every new release breaks something that used to work. I believe every project should be connected to GitHub, and you should know how to use version control. Then bad changes are easy to roll back. And if something broke in some intermediate version, you can always open the history, see how it was done and restore it.

How you work with the agent matters just as much. Write prompts in a way that saves tokens. Keep context in files and write detailed documentation. And definitely create a pitfalls file where the agent notes for itself what to do and what not to do, which errors it ran into and how it solved them. Basically, it’s the project’s accumulated knowledge base that keeps the agent from stepping on the same rakes. Just check it from time to time: after a failed attempt, the agent can write down the wrong conclusion too. It also helps to add files to the project about how you handle design, how you do reviews and deploys, and so on. Then the project is easy to find your way around, and development becomes genuinely enjoyable.

With all that in mind, it’s worth honestly asking yourself: should you even start building something to sell? And if you do, does it all need to be this complicated? Maybe adding a Donate button is enough. Then people can judge your product for themselves and pay as much as they think it’s worth. My forecast is this: in a couple of years, people will buy programs less and less, and a lot of software will become free and run on donations. I may be wrong about the timing, but I think that’s the direction.

It’s important to separate two models here: selling a product for maximum profit, or distributing it for free and getting voluntary support. I’ve long been for the second one, though I don’t rule out the first. All my scripts are free or shareware, meaning you can use them without paying. Yes, an offer to buy a license might pop up here and there to support further development. Maybe that’s slightly pushy marketing on my part, but it really does help keep the products going. Otherwise nobody would pay for them at all.

I usually set the minimum price, basically the cost of a cup of coffee. And most importantly, people should understand that once they buy the program, it’s theirs. The license is permanent: no subscriptions and no extra costs over time. Buy it once and just use it.

And really, what’s the point of hoarding a tool, or selling it at a high price, when it wasn’t even written by you but by AI? How much are you actually going to make from it? You already built it faster than a programmer could. Yes, you burned maybe 100–200 dollars' worth of tokens, but trust me, donations will bring you back much more.

Understanding all this, I created MaxPkg. It’s a platform where people can publish their products, made on their own or with the help of AI agents. They’re easy to prepare and upload to the site, and the storage is already there. You don’t have to think about infrastructure: where to store files, how to build your own website and so on.

The whole idea of MaxPkg is to distribute free scripts specifically and make them easy to share. I think in the near future basic tools will become much more accessible and cheaper, and this model will only feel more natural.

MaxPkg also takes a good chunk of that other 70 % of the work off the developer’s plate. You can write a script with AI quickly, but then you need to host it somewhere, make a product page with a description and screenshots, and set up updates and easy downloads for users. The platform takes care of all that. You get a clear chain: come up with an idea, write it with AI, package it, publish it, get users and feedback.

Plus, there are always users hanging around the site. They’re constantly looking for something and will most likely try your script too. So the main thing is: make your scripts free. Then people can try them without risk and see whether they need the tool or not.

Add a donation link to your scripts and publish them on the site, and a Donate button will appear on the package page too. That’s enough. If the product is really good, people will support it. And if the idea is weak, you’ll see it in the download stats.

If you’ve never written scripts before, check out the MaxPkg documentation: it has articles to get you started. But overall it’s simple. You tell the agent what you want to make and which site it’s for, which is maxpkg.dev.

It’s also a good idea to install Max Ultra MCP. This script works as a bridge between 3ds Max and your agent. With it, the agent can work more easily without you: testing, debugging and doing lots of other useful operations on its own. When the script is ready, just say it needs to be packaged for maxpkg.dev. The agent will do everything automatically, because Max Ultra MCP has built-in skills that know how to work with this site. I covered it in more detail in a separate article.

Publishing is easy too. You need to register, apply to become a developer, and then you can upload your packages right away. The package already contains all the necessary information: you just drag in the archive and fill in the basic details once, like a short description, images, screenshots and so on. You can ask the agent to write the description, FAQ and other texts as well. All the steps are in the publishing guide.

Time will tell how this all plays out. But judging by how quickly Photoshop and ZBrush were replicated, many expensive programs and plugins will become cheaper or completely free.

I think in a year or two we’ll see just how much the software market changes. There are already reverse-engineering repositories like REA, and with tools like that you’ll be able to replicate the functionality you need for a couple dozen dollars.

That’s the crazy world we live in. I think we’re passing the point of no return, and anyone building their own products today should start thinking about this now.

You can build something cool from your own idea today. Install Max Ultra MCP: it installs very quickly and is easy to set up. After that, you give the agent commands, and it writes complete scripts and takes care of most of the programming. What you need is the idea and an understanding of what the result should be. A lot of the rest you can hand off to the agent.

Of course, there are nuances worth knowing: how to set up version control, your environment, skills and rules, which prompts work best, how to spend tokens more efficiently and how to ship releases properly. I’ll write about this in upcoming articles, and maybe I’ll put together a separate course soon.

If this idea interests you and you’d like to try building something of your own, let me know in the comments. That way I’ll see you need it, and I’ll release not only articles but also videos on YouTube.

Have you already replaced a paid program with your own AI-built utility? And do you think you’ll even be buying software in a couple of years?