Ten stages, from the client's first message to a system in production. A specialized AI agent works in each one and, where it matters, the human team decides. Scroll down and walk through the flow stage by stage.
The flow
Animated diagram for this stage: Ten stages, E0 to E9, lighting up in order; three pillars (artificial intelligence, automation and human expertise) orbiting as one system; and the team: ChatGPT analyzes, Claude Code executes on code, files, Jira, GitHub, tests and deployments, local models process sensitive material and Claude Design turns requirements into screens. The human team decides.
This is how WITS builds custom software.
The flow, in short
WITS's custom software development process takes a project from the client's first message to a system in production in ten stages: sources, user story, questions to the Product Owner, design, analysis, development, testing, pull request, CI/CD and return measurement. A specialized AI agent works in each stage (ChatGPT analyzes, Claude Code executes, local models process sensitive material and Claude Design generates screens) and, where it matters, the human team decides.
Updated · · Reviewed by Samuel Hinojosa, CEO of WITS
E0
A WITS custom development starts before any code is written: the project's real sources are gathered (the client's emails, WhatsApp chats, meetings, recordings and documents). AI processes each source: it transcribes audio, analyzes screenshots and links conversations. With everything consolidated, the first User Story and its UML model are built.
E1
The User Story is the project's source of truth. Claude Code queries Jira, retrieves the ticket with its comments and attachments, and normalizes it to the WITS standard: context, business rules and acceptance criteria.
E2
Before designing or coding, the AI reviews the User Story and detects ambiguities, contradictions and pending decisions. It posts self-contained questions directly in Jira, the Product Owner answers and the answers are applied across all the related analysis. That's how WITS avoids building on assumptions.
E3
With the requirements closed, Claude Design generates the screens and user flows with the client's identity: colors, typography and brand. The client sees what will be built before development starts, the WITS team reviews and validates it, and that mockup becomes the visual reference for the analysis and the frontend.
E4
Claude Code breaks the User Story down into perspectives: backend, frontend, database, QA, CRUDs and functional analysis. Entities and relationships are identified, and acceptance criteria become verifiable scenarios, so development and testing never read the story differently.
E5
Backend and frontend move forward in parallel. The backend builds the API with the project's conventions (consistent schemas, modules and services) and the frontend uses those contracts and the mockup to build the experience. Review agents check that the code follows the standards: code inside an architecture, not just generated code.
E6
Before integrating, WITS tests: Pytest validates the backend, Vitest the frontend's services and components, and Playwright the complete flows the way a person would use them. If a test fails, the system analyzes, fixes and reruns until everything is green.
E7
With the change ready, the AI prepares the Pull Request with a summary of what was built and the test evidence. At the same time it updates Jira and creates the backend and frontend subtasks, so code, tests and project management stay in sync without duplicated admin work.
E8
Every commit triggers the continuous integration and deployment pipeline. Security runs first (secrets, dependencies and static analysis), then tests and the build. If everything checks out, the change moves to production on its own; if something fails, there's a rollback. Nobody copies files to the server: the pipeline is the only path to production.
E9
In production, the software stops being a project and becomes a business tool. WITS doesn't stop at deployment: it measures sales, investment, usage, results and return, and turns technical data into indicators the client understands.
Related
Service
The service: systems built around the operation. This page shows how we build them from the inside.
See serviceAfter go-live
Once the system is in production: how questions, bugs and improvements come in, get classified and get resolved.
See flowHow we work
WITS processes from the inside, stage by stage: what the AI does and what the human team decides.
See indexFrequently asked questions
In ten connected stages: sources and prior analysis, user story, questions and answers with the Product Owner, design, automated analysis, development, automated tests, pull request and Jira, CI/CD with security, and production with return measurement. Each stage feeds the next and each AI agent has one responsibility.
It doesn't use a single AI for everything. ChatGPT analyzes and interprets information; Claude Code executes on code, files, Jira, GitHub, tests and deployments; local models process sensitive material without leaving the machine, and Claude Design turns requirements into screens. Where it matters, the human team decides.
Sensitive material is processed with local models, without leaving the machine. They are used to transcribe recordings, analyze screenshots and link conversations to build the first User Story.
Before coding, the AI reviews the User Story and detects ambiguities, contradictions and pending decisions. It posts self-contained questions in Jira and the Product Owner answers them; the answers are applied across the whole analysis. Then the acceptance criteria become verifiable scenarios shared by development and testing.
Yes. In the design stage, Claude Design generates the screens and user flows with the client's identity (colors, typography and brand). The client sees what will be built before development starts, and the WITS team reviews and validates that mockup.
With automated tests at three levels: Pytest for the backend, Vitest for the frontend's services and components and Playwright for the complete flows. If a test fails, it's analyzed, fixed and rerun. On top of that, the CI/CD pipeline runs security and tests again on every commit.
Only through the CI/CD pipeline. Every commit goes through security (secrets, dependencies and static analysis), tests and the build; if everything checks out, it moves automatically to production and, if something fails, there's a rollback. Nobody copies files to the server by hand.
WITS measures the system in production: sales, investment, usage, results and return, turned into indicators the client understands. Day-to-day operation (questions, support, bugs and improvements) follows the software support and maintenance flow.
Let's look at your project
We review your idea or your current system and tell you how we would take it from requirements to production. No cost, no commitment.
