Developing with AI: What Actually Matters in Practice
Michael Norsky
Senior Program Manager at iTSM Group
Lessons from a ServiceNow application project, told from the perspective of the business expert working with a two-person development team. The lessons apply across platforms.

Vibe coding and the announced end of software development
The narrative is hard to escape at the moment: describe what you want, the AI builds it, developers are no longer needed, and classic software applications will soon be history anyway. The demos are impressive. The conclusion is wrong, for two reasons that reinforce each other.
First: what comes out of it are prototypes. Well meant, often surprisingly pretty, and misleading for exactly that reason. They cover rudimentary functions, do not survive serious scrutiny, do not scale and cannot be configured. The gap between “it works in the demo” and “it works with real roles, real data volumes and real edge cases” is precisely the work that vibe coding skips. Then again: when new functions are needed, the AI can simply rebuild the whole thing from scratch. Which sounds rather less reassuring on second thought than it does at first.
Second: the AI results that really work are reconstructed, not invented. Where AI convincingly delivers entire applications today, these are at heart reconstructions of known patterns the ten-thousand-times documented to-do tool, the standard shop, the typical CRUD (create, read, update and delete) backend. The model already knows the solution. On a genuine greenfield problem, in a domain with its own logic, with a data model that has never existed in that form, the same capability tips over into plausible guessing. That is where domain knowledge decides not prompt skill.
None of this means AI is overrated in development. It does change the work profoundly. Just not in the sense that specification, architecture and verification disappear rather that they matter more than before. That distinction is exactly what separates vibe coding from professional AI-assisted development: specification up front, tests and reviews, verification before delivery.
Before turning to the how, it is worth looking at the economic version of the same thesis.
Why “everyone builds their own software” does not add up
The stronger version goes: if everyone can build their own software, standard products are no longer needed. Six observations from a project carried through argue otherwise.
- Code was never the bottleneck. The work was in clarifying, scoping and verifying not in writing. That does not disappear because the AI types faster.
- Built is not the same as usable. Master data, test evidence and operations decide the value, not the completion of the code.
- Operations is the product. A vendor sells releases, security, availability and support. Nobody builds that on the side.
- Platform knowledge remains. The expensive mistakes in the project were platform- and process-specific, not model errors. That knowledge cannot be trained away.
- Liability and regulation. Certifications, data protection, auditability: with a self-build, nobody stands behind any of it.
- The economics do not flip. Roughly 6,600 configurations for a single business application only pay off if something is built once and used many times.
What really changes is something else: it is not the standard that dies, but the justification for expensive custom development of things that already exist as a standard. The custom edge around the standard gets cheaper the standard itself becomes more valuable.
Where these experiences come from: the Tender Management project
A word about ourselves first: we Stefan Kühne, Daniel Radukic and I have just completed our first fully AI-assisted project. We learned a great deal along the way, some of it the uncomfortable way, and we can now tell hype and reality apart far better. This article is an attempt to pass on exactly that distinction.
The basis is the Tender Management project: a business application on an enterprise platform covering the complete tender lifecycle from the incoming tender through qualification, requirements analysis and effort estimation to the finished proposal document. It was developed with an AI coding agent from the very first commit. Not as autocomplete, but as an agent that independently writes source, builds, ships after approval, verifies in the running system and closes work packages.
The setting in numbers:
- 40 build units in around seven weeks to MVP. Two developers, no separate QA team, one shared development environment.
- Around 6,600 configurations in one versioned application. The chain from the incoming document to the finished proposal runs end to end in the system.
- Seven project-specific lint scripts. Every one of them was written in response to a concrete incident, not taken from a best-practice list.
- One AI feature inside the product itself. The automatic classification of incoming tenders was also built with the agent AI building AI, in the same cycle.
What follows in this article is therefore not market observation and not an inference from vendor promises. Every rule and every mistake below was observed in this project, with evidence in the running system, in work packages, commits and a chronologically maintained decision log. Where something was not measured, it says so.
That applies explicitly to the uncomfortable findings as well: the first version was unusable. Test criteria exist but have never been demonstrably executed. And the biggest blocker today is not the code; it is data maintenance. That is precisely why we consider the experience solid it was lived, not retold.
Vibe coding and professional AI development
Both let the agent write. The difference lies in what happens before and after.
| Aspect | Vibe coding | AI-assisted development |
|---|---|---|
| Starting point | An idea, described in words | Approved specification and build plan |
| Approach | Try until it feels right | Bounded unit, verified live |
| Checking | By eye it runs, doesn't it | Real roles, evidence on closure |
| Knowledge | Stays in one person's chat history | Rulebook and log in the repository |
| Mistakes | Repeat themselves | Learned once, enforced thereafter |
| Operations | Not provided for | Part of the cycle |
| Suited to | Prototype, demo, throwaway tool | Systems meant to live for years |
Vibe coding is not wrong. For throwaway work it is the right choice. For anything that goes into operation, it lacks everything except the writing.
The prompt is not the problem
Anyone letting an AI agent loose on a real project for the first time expects quality to depend on the prompt. It barely does. What matters is whether the agent finds an environment in which it can work reliably over weeks.
That is a question of organization, not of tooling. A model that writes good code is a precondition, but it does not explain why two teams with the same tool achieve completely different results. The difference lies in specification, in how tasks are cut, in verification, and in how a project records its own knowledge.

The principles that follow come from a project developed entirely with an AI coding agent from the first line onwards: around 40 build units over roughly seven weeks, two developers, no separate QA team. They are deliberately phrased independently of language, platform and the model in use.
Three levels of “AI” and why they must be kept apart

In almost every discussion, three independent things get mixed up. Without that separation, there is no meaningful conversation about method.
- AI in the application. The delivered solution itself contains AI functions analysis, classification, summarization, assessment.
- AI in development. The solution is built with a coding agent still with code, SDK, Git and development tooling. This is not low code.
- The agent context. Several agents work in different sessions and on different machines and all of them need to know the same state.
An application can contain AI while its development proceeds classically with code and tools. One does not follow from the other. The third level is the one most often overlooked and the one that decides in practice whether a team becomes faster or merely busier.
Principle 1: The specification is the guidance
Without a settled target picture, you get an agent that produces plausible but arbitrary code. That is the most common reason pilot projects fail not insufficient model quality.
Three things should exist before the first line of code:
- A business concept: data model, roles, process logic. Rough is fine, but it has to be decided.
- A translation into technical terms: which component, which interface, which sequence.
- A breakdown into small, numbered build units, each with one bounded, verifiable result.
An agent then builds to the specification instead of to intuition and it does so consistently over weeks, which human teams tend to find harder. The blank page is the real opponent, not a lack of experience with the tool.
How that specification comes about matters just as much: not by uploading existing files, but in dialogue. The requester describes what they want, the agent asks back, the requester fills the gaps. Sketches, screenshots and tables are converted into normalized form along the way, and the agent regularly finds contradictions nobody had noticed before.
Which leads to the most uncomfortable insight of the whole subject: writing code is not the bottleneck. The bottleneck is the question of what should be built at all, whether it is needed and whether it creates value. Requirements engineering is the actual work, and AI does not make it smaller, it makes it more visible.
Principle 2: What the agent cannot see does not exist for it
An AI agent can only work with what it can read, write and version. Everything outside that configuration in a user interface, knowledge in people's heads, agreements in chats is invisible to it and drops out of every decision.
From this follows a plain requirement: the state of the project belongs in files, and those files belong under version control. Only then do the things that make the real difference appear a branch per work package, a traceable diff, a build that runs locally, a review that refers to concrete changes.
The side effect is bigger than it sounds: whatever can be versioned can also be checked mechanically before every merge, without anyone having to remember.
Principle 3: The context belongs to the team, not to the person
This is the central insight and the one most often skipped. AI tools make individuals faster. Only a shared knowledge context makes teams better.
In practice there are two models:
-
Model 1 AI as a personal tool. Everyone works with their own tool and their own context. Only the finished result flows into the project; the route, the reasoning and the intermediate states stay local. Everyone knows something different, mistakes are made repeatedly, and more participants simply mean more islands.
-
Model 2 AI in the context of the undertaking. The project has its own knowledge context with its own repository. Everyone works against the same specification, the same rules, the same work list. Personal tools remain allowed but inside the context of the undertaking, not alongside it.

The difference is not the tool; it is where the context sits. In model 1 you hand over a finished object, and nobody knows how it got there; in model 2 you hand over an artefact together with the decision and the reasoning. Model 1 also produces shadow AI without data protection control, whereas model 2 lets permissions and traceability be governed.
Anyone using AI only as a per-person point solution does not see the dependencies between parallel undertakings and ends up building the same parts twice, or in the wrong order.
Principle 4: Small units, fast loops, deliberate approvals
An agent is most reliable when the task is small enough that its result can be checked in a single step. One unit, one bounded result, one verification. Large, vague assignments produce large, vague results and the checking effort eats up the speed gain again.
At the same time, fixed human approval points are needed. The dividing line that has proven itself runs where an action is hard to undo writing, building and checking run autonomously; anything that changes the outside world merge, release, access to productive systems is an explicit checkpoint.
That keeps speed and control together instead of playing them off against each other.

It gets interesting when you look more closely at what such a unit actually is. Every idea and every requirement runs the same route: research, define, elaborate, align, validate, develop, test, roll out, communicate, collect feedback, evolve and out of the evolution come new ideas that start the route all over again. Developing and testing are only two steps out of twelve. Everything before them decides whether the right thing gets built; everything after them whether it lands.
The second part is the decisive one: this cycle is not a single ring. New ideas and requirements can arise at any point during research just as much as during testing or in operations. Each of them starts its own cycle. One ring turns into a network of parallel undertakings, all of them feeding the same goal.

This is exactly where small units alone turn out not to be enough. These cycles overlap: two need the same data model, so one has to wait until the other settles it. Two builds on the same component, so they run in parallel but with an agreed interface. Several must be rolled out together. And feedback from one solution generates ideas for the next.
Recognizing these cross-connections is the real coordination work, and it is the task for which an agent with complete context is better suited than any single person. It sees all open requirements at once, notices when two contradict or block each other, links dependencies and puts them into a workable order. Provided and this is the condition from principle 3 that all cycles sit in the same knowledge context. Otherwise, the overlaps are simply invisible, and things get built twice or in the wrong order.
Many small units, one shared goal, and an agent that keeps track of their dependencies: that is the difference from an approach that merely cuts work into tickets and then hopes the pieces fit together.

Principle 5: “Build is green” is not proof
The most dangerous class of error looks like success from the outside: build successful, deployment successful, positive feedback and in the running environment it still does not work.
The patterns behind it repeat themselves:
- A platform or runtime silently refuses a change because it enforces limits of its own. The result does not look like an error.
- An access rule is assumed to be restrictive although a default setting undercuts it the restriction was never in effect.
- Two layers contradict each other in an edge case that never occurs on the normal path.
None of this is an “the AI got it wrong” problem. It is environment-specific knowledge that was documented nowhere until it went wrong once. It cannot be trained away only written down.
Result: verification happens against the running system, under real permissions, and independently of the agent's own account of itself. “I tested it” does not count; traceable steps and queries do.
The same attitude applies one level earlier, on the business side. An agent often produces solutions you would not have designed that way yourself technically clean, operational, and still not what was meant. With multi-stage processes and dependencies in particular, the result must be read against the original requirement again after every structural change. “It works” and “it does the right thing” are two different checks.
A related point concerns error handling. A fallback that returns a value indistinguishable from a normal result makes the error invisible forever. In one real case, a processing chain silently discarded around 14 per cent of incoming records over several weeks there was simply no query that would ever have found it. The most useful rule of thumb: if this case occurs in production, which query finds it? If the honest answer is “none”, a marker is missing.
And there is a third level to the same question, one that only becomes visible once everything is built: built is not the same as ready to use. Three findings that surfaced in the project described only after all build units were complete:
- Repetition without determinism. Running the same AI analysis again produces duplicates. Matching on exact text fundamentally cannot work against a non-deterministic model it needs a business key.
- A test artefact is not testing evidence. Automated test criteria had been created and signed off. Not one of them was demonstrably executed.
- Data as the quality ceiling. The code was finished and the analyses were running against almost empty master data. Data maintenance was not a build unit and appeared in no plan.
The definition of “done” does not end at the code. Test evidence, data maintenance and repeatability belong in the same plan as the build units otherwise they are exactly what is left lying around while everything else is complete.

Principle 6: The project learns, not the model
A widespread misconception is that the agent “learns as it goes”. It does not every session starts without memory. What can learn is the project, if you set it up for that.
Two artefacts carry that learning:
- A living conventions document. Every recurring mistake is recorded there, with its reasoning and how to recognize it. That is not an accessory, it is the memory of the system across sessions and developers.
- A chronological decision log. Appended to, never overwritten. It makes it traceable why something is the way it is without anyone having to search through chat histories.
A third step makes the difference between documentation and effect: every rule broken twice becomes a script that runs automatically before each merge. People forget, agents start without prior knowledge a mechanical check does neither.
In the project described, seven project-specific lint scripts came about this way. Every one of them originated in a concrete incident, not in a best-practice list.
Principle 7: Trial and error instead of a perfect landing
Classic software development aims for the perfect landing: requirement, design, implementation, ideally correct on the first attempt. AI-assisted development works differently. It is exploratory: build, check, discard, build again. An agent has no trouble rebuilding a data structure or a user interface from scratch with all the consequences.
Whether that is a strength or a risk depends entirely on what is being worked on:
- A new system: a pronounced strength. You are confronted with aspects you would not have thought of yourself; quite a few data model decisions only became visible through the actual building.
- An existing, productive system: exactly what you want to avoid there. A rename that ends up as a duplicate next to the original. A removed field that leaves orphaned data behind. Both are real cases, both with consequences for users and migration.

In most cases the agent points out such risks itself for the solution it depends on a human. Which structure stays, how orphaned data is migrated, whether a rebuild is worth it at all: those are judgements whose reach goes beyond the individual build step. In one case the agent confirmed a larger rebuild as technically feasible the right decision was still to drop it after weighing cost against benefit.
From this follows the actual shift in roles. People write less code and make more decisions instead: what gets built, what it should mean in business terms, what is risky enough not to run automatically. Worth noting in this project a purely business role could be involved through tickets alone, with no code access whatsoever. Requirements flowed in without that person touching tools or process. The gap between business and development gets narrower, not wider.
The learning curve: the first version was unusable
This part is usually left out of reports on AI development. It is, however, the justification for every single rule above.
The starting point was the normal case: requirements in inconsistent form screenshots, individual tables, status lists, scattered artefacts. The entire body of material was processed once in full; out of it came the specification, out of that the plan, out of that the first work packages.
The result looked professional and was unusable in substance: technically inconsistent, not traceable as a process, not usable in the interface. What had been created included around 50 tables with some 40 relations.
The correction consisted of four points that govern the approach today: work iteratively instead of in one go, let the agent ask back, cut smaller units, validate early.
Part of that is a habit you must train yourself into: challenge the agent's proposal instead of merely improving it. A plausible proposal is not yet a need. In one scoping round, three short questions what already exists? which assumption is unsupported? is there an option to build nothing at all? brought the scope down from 24 to 15 items. The lesson is not that less is always better, but that checking existing functions before building changes the scope.
The honest framing: under which conditions this holds
Without this section, everything said so far would be disingenuous. The project described ran under conditions that are rare.
What helped: exactly one business requester who knows the business and can decide instead of twelve parties with competing wishes. Two very experienced developers who could judge the agent's results on their merits. No customer data, a controlled use case.
What was missing: a governance layer for competing requirements a second requester would today run into the project unfiltered. Narrow permissions in our own environment. A tool rollout still in the trial stage.
The most dangerous point is a different one: if the developers have mastered the technology in use for years, they can judge the agent's results. With a new technology and no experience of their own, exactly that control instance falls away and with it the basis for everything said here about verification.
What to know before you start
One point is rarely said out loud: entering AI-assisted development is a long-term commitment, and it begins with the first generated commit.
The reason is not licensing; it is the shape of the knowledge that accumulates. The code deliberately stays free of comments; the why moves into a conventions document grown chronologically in the project described more than 100 pages, written for an agent with a large context window, not as compact architecture documentation for a new human developer. Anyone taking the project over later without an agent would have to do exactly the reconciliation work the agent does automatically before every step today.
That is not an argument against it. It is an argument for making the decision deliberately and for maintaining the conventions document from day one as if the project depended on it. Because it does.
Checklist for the start
“The biggest lever is not in the individual project. It lies in the next team not having to rediscover the same traps one by one.”
Putting AI-Assisted Development into Practice
Business Swiss connects Swiss business and technology leaders with expertise in AI, enterprise software and digital transformation. Michael’s Tender Management project gives those leaders concrete practices to discuss with their teams, from agreeing on requirements and sharing project knowledge to verifying that an application works in its live environment.

About the author
Michael Norsky
Senior Program Manager at iTSM Group
Michael Norsky brings more than 30 years of experience in IT, enterprise software and digital transformation. He has held senior roles at IBM, UBS, Oracle, SAP, ServiceNow, NTT DATA and DXC Technology. His expertise spans Enterprise Service Management, ServiceNow, and HR and business process transformation. Before joining iTSM Group, he led strategic ServiceNow engagements, including at Swiss Federal Railways (SBB). Today he helps organisations translate business requirements into effective digital solutions and improve their processes through modern service management platforms.

