Why I’m pausing Squillify

Squillify began as a side project with a simple personal objective: to learn how far AI-driven software engineering could really go.

I did not want to build another small AI demo or add a chatbot to an existing application. I wanted to use AI throughout the engineering process and see whether one person could turn an idea into a credible, scalable software product.

What followed went far beyond anything I had initially intended.

Bringing the micro-SaaS idea to AI agents

The original concept came from transposing the micro-SaaS ecosystem into the agentic world.

Today’s AI agents are remarkably capable, but they remain probabilistic. They can reason, plan, and generate—but many everyday software tasks still require an exact, repeatable, and verifiable result. Validating a schema, normalizing a dataset, masking personal information, producing a cryptographic signature, or safely manipulating a file should not depend on whether a language model happens to get it right.

Squillify was designed as a dependable utility layer for those agents: a catalog of small, focused services called MicroSkills.

An agent can connect through MCP or REST, search the catalog for the capability it needs, retrieve a machine-readable contract, and execute the selected skill. Instead of exposing hundreds of tools at once, Squillify gives agents three stable operations: search, inspect, and execute. The catalog can grow without continuously increasing the agent’s context or integration complexity.

By the time I decided to pause the project, Squillify had grown far beyond its original collection of utility functions. The platform now offers 753 verified MicroSkills across 32 categories. They span text, data, documents, files, media, web and HTML processing; code and software engineering; schemas and validation; security and cryptography; identity and access; databases, APIs, DevOps and observability; AI, agent utilities, knowledge retrieval and workflow automation; as well as specialist business capabilities for finance, accounting, legal, compliance, governance, commerce, productivity and internationalization.

These are not simply hundreds of endpoints placed in a catalog. Each MicroSkill is a focused execution primitive with a typed contract, validated inputs, structured outputs, versioned behavior, a declared reliability mode, and explicit information about latency, cost and data handling. Skills are designed to be discovered dynamically and composed by agents into larger workflows. When an execution fails, structured reasons and permitted recovery options can help the agent repair the problem, retry and continue toward its objective.

That breadth changed the nature of Squillify. What began as a dependable toolbox for tasks language models should not be trusted to perform approximately became a genuine execution layer for AI systems—one that helps agents find the right capability, understand how to use it, execute it under policy and cost controls, and leave behind an observable and auditable trail.

More than a collection of utilities

My background is not in building quick prototypes. It comes from nearly 30 years of building and running large-scale software organizations, often in regulated corporate environments.

That experience shaped Squillify from the beginning.

Behind a simple skill invocation is a multi-tenant platform with API-key authentication, tenant and skill-level permissions, quotas, concurrency and rate controls, durable usage metering, billing foundations, privacy declarations, temporary file handling, structured error contracts, and extensive operational telemetry.

Skills are versioned, machine-discoverable, and automatically subjected to contract tests. The platform was designed to support a catalog of thousands of skills and to scale horizontally. It has been exercised under meaningful load, including tests involving hundreds of concurrent agents.

Squillify is not perfect, and I do not want to pretend that every last step toward production was complete. But it is much more than a concept or a polished mock-up. The platform works, the core product flows are implemented, and it has demonstrated that it can do its job at realistic scale.

The AI rule

One of the rules of the experiment was that the solution had to be coded through an AI-driven engineering process.

I took that rule to the extreme: entirely solo dev, 1.2 million lines of codes produced. I refused to touch any of them.

I provided the product vision, architectural direction, requirements, constraints, reviews, and engineering judgment. During 6 months, AI tools produced and iterated on the implementation. This applied not only to features, but also to tests, security controls, operational tooling, documentation, load testing, and the less glamorous work required to make a system dependable.

This experience was deeply eye-opening. I quite literally fell down the AI rabbit hole.

It showed me both sides of AI-assisted engineering. AI can give one person extraordinary leverage, but it does not remove the need for judgment, discipline, or experience. It can produce code at breathtaking speed; someone still has to ask the right questions, recognize weak assumptions, design for failure, and decide what “good enough” actually means.

The nearly production-ready first version of Squillify is the result. For me, it is also proof of what a passionate and admittedly somewhat rusty technologist can now create with a strong idea, decades of experience, persistence, and modern AI tools.

Why stop now?

I was recently approached to join a large organization for a strategic and genuinely exciting mission. The role draws directly on my 30 years of experience building and operating large-scale software organizations.

It also requires strict independence.

Continuing to own, develop, and operate Squillify would create a direct conflict with those responsibilities. There was no honest or responsible way to pursue both properly, so I had to make a difficult choice.

I have therefore decided to freeze Squillify in its current state, just before it reached the finish line of its first production version.

This is not a decision driven by a lack of belief in the idea. Nor is it a conclusion that the experiment failed. On the contrary: Squillify went considerably further than I expected when I began.

What happens now?

Active product development and launch preparations are paused indefinitely.

I plan to produce a series of videos showing what Squillify does, how agents interact with it, and what was built behind the scenes. I will leave the product and this website available as a record of the journey—a witness to how far one curious and determined person can go today with the help of AI.

I do not yet know whether Squillify will return, when that might happen, or what form it could take. I would rather be honest about that uncertainty than make promises I may not be able to keep.

For now, this chapter pauses here.

To everyone who followed the journey, tested ideas, asked questions, challenged assumptions, or simply encouraged me along the way: thank you. I am deeply grateful for your interest and support.

Squillify has been one of the most intense and rewarding learning experiences of my career. I am proud of what it became and tremendously excited about what comes next.

Vincent Eggen, AI augmented rabbit ;)