Generative UI: what it is, how it works, and when to use it

Kaizen Softworks is Certified in the Claude Partner Network.

This milestone recognizes the Claude training and certifications completed by members of our team. It also reflects work we've been doing across Kaizen: testing how AI can improve software development and exploring new ways to build AI into products.

For your team, that could mean testing a product idea earlier, finding information across internal systems, or reducing manual work in an existing process.

We've been exploring these opportunities through internal experiments and client projects. Now we're bringing that experience into services designed to help you identify where AI makes sense and turn promising ideas into working software.

What being Certified means

The Claude Partner Network is how Anthropic works with firms that help customers bring Claude into production. Its Services Track recognizes progress in developing certified teams, delivering Claude use cases, and demonstrating customer work.

Certified is the first partner tier. It recognizes firms whose team members have completed Claude training and earned Claude certifications.

For Kaizen, this is another step in building our team's AI capabilities. The certifications add structured learning to the practical work we've been doing through our Innovation Hub.

How AI is changing the way we build software

AI is changing how we work across the software development cycle, from exploring ideas and designing experiences to writing code, testing, and releasing improvements.

AI-assisted workflows can help teams build up to 6× faster at a fraction of the cost. The actual gains depend on the project, the tools involved, and how the work is organized.

Our experience has shown us that speed alone isn't enough. AI-generated work still needs clear requirements, technical judgment, and careful review to ensure the software is reliable and maintainable.

For clients, this creates opportunities to explore ideas, validate decisions, and ship improvements faster, with less development effort and lower costs.

How AI changes what your product can do

Using AI to build software is different from adding AI capabilities to a product.

When AI becomes part of your product, the starting point is what users need to accomplish.

Maybe they need to find information across several systems. Maybe your team spends too much time gathering context before making a decision. Or perhaps there's a repetitive task that could be completed with less manual effort.

AI can help with these needs, but making it useful takes more than connecting to a model.

We help define what information AI can access, which actions it can take, when people need to be involved, and how the product should handle incomplete or incorrect answers.

What this means for our clients

Whether you're building a new product, improving an existing platform, or modernizing software, AI creates opportunities worth exploring. Your product doesn't need an AI feature for your team to benefit from AI-assisted development.

Here's how we can help.

Test ideas earlier. AI-assisted prototyping and design exploration can help your team review ideas sooner. You can identify usability issues, gather feedback, and decide what's worth building before committing to a full implementation.

Find where AI fits your project. Not every workflow needs AI, and results depend on your systems, requirements, and team. We help you identify specific opportunities, test them, and decide whether the improvement justifies further investment.

Turn promising ideas into working software. A successful experiment is a starting point. We support the design, integration, testing, and engineering work needed to make software reliable, secure, and maintainable.

Our certification marks progress in developing the skills behind this work. What matters for clients is how we put those skills to use.

Services built around those needs

Your team may have useful information spread across applications, databases, and internal systems. Finding an answer often means searching through several tools. Our Custom MCP Connector service helps connect those systems to AI tools such as Claude, so users can find approved information without navigating every system separately.

Some processes involve the same steps every time: reading a request, gathering information, and deciding what happens next. Our AI Agents service helps identify which parts of those processes AI can handle. We define the task's boundaries with your team, including which tools the agent can use and which decisions require human approval.

A prototype can show that an idea works. Making it reliable enough for everyday use requires more work. Our Prototype to Production service helps your team take an existing prototype further, addressing how it connects with your systems and what it needs to run reliably. That includes defining expected behavior, improving code quality, addressing security, preparing deployment, and planning maintenance.

Where to start

Start with a change worth making.

Choose one workflow or product need. Identify what takes time, where information is difficult to access, or what prevents users from completing a task.

Then define what an improvement should accomplish.

That might mean less time searching for information, fewer manual handoffs, or a task users can complete with less assistance.

Start small, evaluate the whole workflow, and use the results to decide what comes next.

If you have a process you'd like to improve or a prototype you're ready to take further, get in touch. We can help you identify the next step and what it needs to prove.

An AI coding agent works with the context your team gives it: existing code, documented decisions, instructions, and reference examples. If that context contains inconsistent patterns, the agent can repeat them.

Before implementation starts, engineering leaders need to define how agents should work and how the team will check their output. Choosing a coding assistant does not make those decisions for you.

For greenfield projects, where the team is building a new codebase, our approach starts with Sprint 0. This is when the team sets the architecture, coding conventions, agent guidance, and verification process.

The setup has two parts: guidance that shapes the agent's work before it starts, and checks that catch problems afterward. With both in place, agents can take on more implementation while engineers stay responsible for how the software is built.

Give agents clear guidance before they build

The codebase is part of an agent's instructions. Its structure and existing implementations show the agent which patterns to follow.

A well-structured starting point gives the agent better direction than an empty repository or inconsistent boilerplate. That makes the team's early decisions important because those decisions become context for future work.

Sprint 0 makes that direction explicit through four elements:

• Architecture decisions. Record key decisions in lightweight architecture decision records, or ADRs, so agents and developers can refer back to them.
• Repository instructions. Use a file such as AGENTS.md to define the rules an agent should follow in the repository.
• Skills and prompt templates. Prepare reusable guidance for recurring workflows.
• Reference implementations. Keep examples that show the patterns and quality the team expects.

The team also needs to decide what agents can access and do. That includes which files and systems they can see, which tools they can use, what they can change, and which reviews they must pass.

Without enough context, agents have to infer what the team wants. Weak constraints can lead to inconsistent implementations.

Setting those boundaries is part of the engineering work that should happen before agents start building.

Set up verification before relying on agent output

Guidance shapes the work, but the team still needs to check what the agent produces.

That process can include:

• Review rules for architecture, security, and token usage.
• Automated tests and linting that check code against defined rules.
• A sign-off process before changes reach production.

Engineering leaders need to define and maintain these checks. Stronger verification gives the team more confidence to delegate implementation work because problems are easier to detect before they reach production.

As agents take on more implementation, engineers can spend more time on architecture, review, and improving the guidance the agents work from.

Start construction with a clear specification

Implementation needs the same clarity: a description of what the team is building.

In this model, Product explores an idea in a separate environment and validates it with customers. Once the idea is ready for construction, Engineering receives:

• A behavioral specification.
• A test plan with acceptance criteria.
• A link to the prototype for reference.

The experimental code stays in the exploration environment.

We cover that handoff in When PMs can ship code, what changes for Engineering?, including what Product should provide after testing an idea.

During construction, the specification defines the behavior the implementation needs to meet, including edge cases and failure modes. Engineering decides how to implement that behavior within the agreed architecture.

This gives the agent a defined target and gives the developer a clear basis for reviewing the implementation.

Keep engineering judgment in the construction cycle

Sprint 0 prepares the environment, but engineers continue making decisions throughout implementation.

The developer chooses the architecture and reviews the agent's execution plan, including which files it will change and which risks it has identified.

During implementation, the developer supervises the work. Before sign-off, the changes go through manual review, automated checks, and security review.

If the work stops matching the specification or architecture, the developer should stop and reset the cycle.

The guidance from Sprint 0 also needs to evolve. As the team builds, engineers can add new rules and examples, update existing ones, and remove documentation that no longer reflects the codebase.

Maintaining the context agents use becomes part of the development process.

Account for the codebase you already have

This approach is easiest to establish on a greenfield project because the team can set the architecture, conventions, and verification process from the start.

Existing codebases are different. Their previous decisions and inconsistencies are already part of the context an agent sees.

Teams can still introduce the same kinds of guidance and checks. Reaching consistent agent output can therefore take more work.

For a new project, Sprint 0 gives the team a chance to make those choices before implementation begins. Define the architecture, give agents clear guidance, put verification in place, and keep engineers responsible for architectural decisions and release approval.

Then keep that foundation current as the codebase grows.

If your team is starting a new project with AI coding agents, we can help you define the architecture, repository guidance, and verification process before implementation starts.

‍