The nature of the relationship between our developer team at KnowNow and our customers has changed.

People who would never previously have considered themselves software developers are now building real systems, solving real problems, and in some cases deploying applications that would once have required an entire development team.

I’ve seen customers move from describing what they want software to do, to directly building working solutions themselves using tools like Claude Code, Codex, OpenWebUI, Ollama and other increasingly capable AI-assisted development environments.

It is an exciting time.

One of the most interesting examples I’ve seen recently has been through our work with Mark Cann at Hyypa. Mark has built an impressive platform focused on helping people experiencing neurodiversity maintain concentration and work more effectively on the right tasks for longer. The quality of the application stood out, but so did the speed at which ideas could move from concept into working functionality.

Previously, translating those ideas into software would almost certainly have involved analysts, developers, specifications, project plans, and long development cycles. Increasingly, the distance between idea and implementation is collapsing.

I’ve seen similar patterns elsewhere too.

One charity we worked with, focused on helping people at risk of homelessness find the most appropriate support services, gradually evolved from relying on an externally developed platform to having their own leadership directly shape and build much of the production system themselves using AI-assisted tooling. Our role increasingly became one of supporting integrations, interrogating existing data sources, and helping structure the underlying workflows.

Even in our CTO-as-a-Service work, we’re now seeing customers independently building highly competent local AI environments using tools like OpenWebUI and Ollama, including embedding and retrieval systems over their own local datasets. In one recent case, we simply maintained a shadow setup alongside the customer’s environment so we could compare notes, validate assumptions, and ensure the hardware was operating within expected bounds.

The most interesting part of the current AI revolution may not be the technology itself, but who it suddenly enables to create.

But while I’m enormously optimistic about this shift, I also think we are beginning to discover the difference between software that appears complete and software that is genuinely ready to be relied upon.

That is a distinction that matters!

The Illusion of Progress

The challenge with AI-assisted development isn’t that the systems don’t work. Many of them do, and often remarkably well.

The challenge is that modern AI tools are extremely good at producing polished, convincing output. Interfaces look professional. Code appears structured. Features seem complete. The overall experience can create a strong sense that the application is already “mostly there”.

In practice though, we are increasingly finding that there can be a significant difference between software that appears complete and software that is genuinely production ready.

AI dramatically accelerates output. That does not always mean it accelerates understanding.

One of the most interesting aspects of AI-assisted development is how quickly systems can now appear substantially complete, often before the underlying workflows, integrations, architecture, and operational behaviours are fully understood by the people building them.

The pattern we have repeatedly encountered is what I would describe as structural residue; remnants of previous ideas, workflows, prompts, and architectural approaches left behind as the system evolves through rapid iteration.

In one recent review, we found multiple folders and files that no longer served any active purpose beyond routing elsewhere or pointing toward superseded approaches. None of this was malicious or even particularly unusual. It was simply the natural by-product of iteratively building and rebuilding at speed.

This becomes especially noticeable when projects are developed primarily through iterative prompting. One issue gets fixed, but another unexpectedly appears elsewhere. The AI successfully solves the immediate local problem, but over time the wider structure of the system can begin to drift and the infamous “spaghetti code” discussion begins to emerge.

What makes this particularly interesting is that the polished nature of the generated output can actually make debugging harder for less experienced developers. Because everything looks correct, there can be a tendency to assume the issue lies somewhere else entirely,  the infrastructure, the hosting, the credentials, the APIs, or the environment – rather than within the generated implementation itself.

We also found that some of the most important areas requiring review were not necessarily the visible features, but the operational foundations underneath them: authentication flows, third-party integrations, credential management, performance, data handling, and the overall structure of the codebase itself.

None of this diminishes how extraordinary these tools are. If anything, it highlights how rapidly software creation is changing.

But it also reinforces something important: as the cost of generating software falls, the value increasingly shifts toward architecture, validation, refinement, testing, data management, and understanding how systems behave as they grow.

What Successful AI-Assisted Development Looks Like  

None of this has reduced our enthusiasm for AI-assisted development. Quite the opposite.

At KnowNow Information we are fully committed to using these technologies ourselves and increasingly encouraging our customers to do the same. The speed at which ideas can now move into implementation is genuinely transformative. In many cases, people with deep domain expertise can now express their ideas directly in working systems without needing to navigate the traditional barriers of software delivery.

What we are learning though is that the most successful projects are rarely the ones that simply generate the most code the fastest.

The projects that tend to succeed are usually the ones where some thought is introduced relatively early around workflows, desired outcomes, data structures, and how the overall system is intended to evolve over time.

In practice, iterative prompting alone can sometimes become problematic. Without some form of architectural direction, development can gradually turn into a continuous cycle of correction; solving one issue only for another to emerge elsewhere.

In many cases, AI-assisted development gets projects remarkably close remarkably quickly. But the final 10–20% of work, the integration, validation, testing, security, refinement, operational reliability, and long-term maintainability –  is often where the majority of the real engineering effort still sits.

That “last 20%” is frequently 80% of the real work.

That is why we increasingly see value in approaches that help structure thinking before large-scale generation begins. In our own work, this often involves tools such as our Data Management Canvas to help organisations understand their workflows, relationships, governance, and data requirements before significant implementation takes place. There are, of course, many other approaches and tools available too.

The important point is not the specific methodology. It is introducing enough structure that the AI has a coherent direction to work toward.

Interestingly, this does not reduce the importance of developers and engineers, but it does change how their expertise is applied. Increasingly, the value sits in reviewing, refining, validating, integrating, restructuring, testing, securing, and improving systems that may already largely exist.

In many ways, the role becomes less about manually producing every component from scratch and more about helping ensure that rapidly generated systems remain coherent, maintainable, secure, and capable of evolving reliably over time.

The most effective outcomes we have seen are not AI replacing people, but domain experts, AI systems, and experienced engineers working together in a much more collaborative way than traditional software projects previously allowed.

Where Humans Will Win  

I do not believe AI will remove the human desire to invent, create, experiment, and express ourselves. If anything, I suspect it may help us to develop it.

Every industrial revolution has changed labour patterns dramatically. Entire categories of work have disappeared, but new industries, new skills, and new forms of creativity have emerged alongside them. I do not think this revolution will be any different.

What may change significantly is the shape of software development itself.

For many simpler requirements, we are likely moving toward a world where people increasingly ask intelligent systems directly for the outputs they need rather than commissioning traditionally developed software applications. As intelligent assistants become more capable, they may increasingly construct their own methods for retrieving, processing, and presenting answers dynamically.

That may reduce the need for certain types of conventional software development, but I do not believe it removes the value of understanding systems, logic, data, or code itself.

In fact, I would still strongly encourage people to learn how software works and to learn how to code. Not necessarily because everyone will become a traditional developer, but because understanding systems increasingly becomes part of maintaining personal sovereignty over our own decisions, outputs, and ways of thinking.

Interestingly, we are already seeing signs that people continue to value human-made and analogue experiences alongside digital acceleration. Vinyl records, film photography, cel animation, physical books, and other forms of slower, tangible creation continue to persist and in some cases return to popularity precisely because they feel human.

Technology changes the tools we use. It does not remove the human desire for creativity, curiosity, independence, and expression.

If anything, I suspect AI-assisted development may ultimately allow more people to participate in creation than ever before. The challenge for all of us will be ensuring that we combine that new capability with enough structure, discipline, and understanding to build systems that are not only impressive, but reliable, maintainable, and genuinely useful over time.

The Future Is Collaborative  

What has perhaps surprised me most over the last couple of years is not the capability of the AI systems themselves, but how quickly people have adapted to working alongside them.

We are increasingly seeing domain experts move directly into software creation. People who understand problems deeply can now participate far more actively in building the systems intended to solve them. In many cases, they are able to iterate faster and explore ideas more freely than traditional development approaches previously allowed.

At the same time, our own role as developers and architects is evolving. Increasingly, the value we provide is not simply writing every line of code manually, but helping review, refine, structure, secure, validate, and stabilise rapidly generated systems so that they remain maintainable and reliable over time.

At KnowNow, we are fully committed to using AI-assisted development ourselves and helping our customers do the same. The goal should not be dependency on development teams where it is unnecessary. The goal should be enabling more people to turn good ideas into working systems successfully.

The best outcomes we have seen are not AI replacing developers, nor developers resisting AI, but collaborative environments where human creativity, domain expertise, engineering discipline, and intelligent systems all reinforce one another.

That feels less like the end of software development and more like the beginning of a very different phase of it.

If you are experimenting with AI-assisted development or “vibe coding” approaches and would value an experienced second pair of eyes around architecture, integrations, data management, security, or production readiness, we are always happy to have a conversation.

Use the Get in Touch button below to start the discussion.