Back to featured insights

AI-Assisted Software Development: A 5-Stage Workflow From Requirements to Code Review

Can AI make software development faster without compromising quality? Discover how Arestós uses OpenAI Codex across the development lifecycle, from requirements analysis to code review, while keeping experienced developers in control of every release.

Table of Content

Share

AI-assisted software development uses AI coding tools to speed up requirements analysis, coding, testing, code review and documentation, while developers keep design decisions and final approval. This article shows a working process: the five-stage workflow our team at Arestós uses with OpenAI Codex, what the evidence says AI does and does not speed up, and the governance Hong Kong enterprises should expect from any development partner using AI.

At a glance: the example used throughout this guide (illustrative)

A Hong Kong retail group runs three WooCommerce storefronts on Odoo Community Edition, with about 25,000 SKUs, recurring overselling and an undocumented legacy sync plugin, a common pattern in multi-store e-commerce operations. Traditional estimate: 880 hours over 12 weeks. AI-assisted estimate: 620 hours over 9 weeks, net of the time spent reviewing and correcting AI output. These figures are an illustrative estimate built on our workflow, not a measured client result.

What is AI-assisted software development?

AI-assisted software development is the use of AI coding tools to help developers analyse requirements, write and refactor code, generate tests, review pull requests and document systems, while human developers remain responsible for design decisions, validation and final approval.

The AI handles repetitive, verifiable work. People decide what gets built, how it is designed and whether it is ready for production.

AI-Assisted vs. Fully AI-Generated Software

Criteria AI-assisted development Fully AI-generated software
Architecture Designed and approved by developers Proposed by the AI, often without review
Coding Developer-led; AI drafts code in small, reviewed tasks AI writes most of the code from broad prompts
Testing Tests derived from requirements; QA validates them Tests generated from the AI’s own code, which can confirm its bugs
Code review AI flags issues; a senior developer approves Review is light or skipped
Accountability A named engineer signs off every change Often no clear owner of design decisions
Enterprise fit Suits controlled, audited delivery Suits prototypes, not production systems

For enterprise systems that handle money, stock or customer data, AI-assisted development is the model that keeps quality and accountability intact.

Benefits of AI-assisted software development: what the evidence supports

AI-assisted development can shorten delivery of routine work and make testing and review more consistent, but the gains depend on the task and are not automatic.

Where the benefits come from:

  • Faster routine work. Drafting specs, boilerplate code, migration scripts, tests and documentation takes less developer time.
  • More consistent testing. Tests generated from acceptance criteria and AI-suggested edge cases widen coverage.
  • More consistent code review. Every pull request gets a first-pass scan for bugs, security issues and coding-standard breaches before a human reviews it.
  • Faster onboarding. New developers can ask questions about an unfamiliar codebase instead of waiting for a senior colleague.

What published studies show:

Study Setting Result
Simplex case study (OpenAI) Web application screens built with Codex 40% fewer hours to design each screen, 70% fewer to develop each screen, 17% fewer for internal integration testing
METR randomised controlled trial 16 experienced open-source developers on their own large repositories, early-2025 tools Tasks took 19% longer with AI; developers had predicted a 24% speed-up and afterwards believed they were 20% faster

The Simplex figures are vendor-published by OpenAI. The METR result reflects early-2025 tools in large, familiar codebases. Read together, they show the gains vary sharply by task type and setting.

Our approach: we measure net hours per stage, including the time spent reviewing, correcting and re-testing AI output. Savings are largest on repetitive, verifiable work and smallest on architecture, discovery and complex business logic.

How AI is changing software delivery in Hong Kong

Hong Kong enterprises are adopting AI broadly, but few have scaled it into everyday delivery.

  • Scaling is the gap. Accenture’s 2026 Hong Kong AI Index found only 3% of Hong Kong companies have fully integrated AI into their workflows, and only 12% of AI initiatives have scaled across the organisation (SCMP).
  • Large enterprises are moving first. Nearly 40% of large enterprises plan to adopt agentic AI, about double the share among SMEs (HKT Business AI Adoption Survey 2026).
  • Financial services leads. 75% of 55 surveyed financial institutions have implemented or are piloting generative AI use cases (HKMA; HKIMR report).

Software delivery is one of the most practical places to scale AI, because the output can be tested, reviewed and measured before it reaches production.

Our toolset and guardrails

Our main tool is OpenAI Codex, used inside fixed guardrails: repository rules, sandboxing, data restrictions and human approval.

OpenAI Codex. Codex is OpenAI’s AI coding agent. It can read a codebase, implement changes, fix bugs, run tests and review code, and it runs on a developer’s computer or in the cloud (OpenAI DevDay 2026). We use it in three places:

  • CLI and IDE for coding, debugging and local test runs.
  • Cloud tasks for longer, delegated jobs such as generating a test suite.
  • GitHub pull request reviews. This requires Codex cloud to be set up for the repository and code review to be switched on; on GitHub, Codex flags only P0 and P1 issues (OpenAI documentation).

Repository rules in AGENTS.md. Codex reads AGENTS.md files before starting any task, combining global guidance with project-specific rules. Each project’s AGENTS.md holds its coding standards, test commands, review rules and modules the AI must not change.

Guardrails:

  • Sandboxed execution with approval settings, so the agent cannot run unreviewed commands against shared systems.
  • No secrets, credentials or client personal data in prompts; workshop notes are anonymised first.
  • Client consent to AI-assisted delivery is agreed at project kickoff.
  • A named developer validates, tests and approves every change before it is merged.

The 5-stage AI-assisted development workflow, from requirements to documentation

Our workflow uses AI at five stages, and each stage ends at a human checkpoint. The illustrative retail project from the introduction runs through every stage. Estimated effort per stage:

Stage Traditional vs AI-assisted (hours)
Requirements & planning
Traditional 80h
AI-assisted 50h
Coding & development
Traditional 420h
AI-assisted 290h
Automated testing
Traditional 200h
AI-assisted 150h
Code review
Traditional 80h
AI-assisted 60h
Documentation & handover
Traditional 100h
AI-assisted 70h
Total 880h (12 weeks) → 620h (9 weeks)

AI-assisted figures are net: they include the time developers spend reviewing and correcting AI output.

Stage 1: Requirements Analysis and Planning

Codex drafts specifications, impact analyses, task breakdowns and estimates; a business analyst and tech lead validate every output before development starts.

Turning business requirements into specifications and tasks

Input What Codex drafts Who validates
Business requirements document Functional specifications Business analyst
Anonymised workshop notes Given/When/Then acceptance criteria Business analystClient
Approved specification Epics, user stories and technical tasks with dependencies Tech lead

Sample prompt: Using docs/brief.md, draft functional specs for the WooCommerce–Odoo sync. Write acceptance criteria in Given/When/Then. List every assumption and every question the client must answer.

From there, the sequence is fixed:

  1. The business analyst takes Codex’s list of open questions back to the client.
  2. Only confirmed answers become requirements.
  3. Codex turns the approved spec into a Jira-ready backlog.
  4. The tech lead reorders it so the riskiest integration work comes first.

Analysing impact on the existing codebase

Codex traces the models, hooks, cron jobs, custom fields and API endpoints a change will touch, and lists the areas most at risk of regression.

Example finding: in the retail scenario, impact analysis would show that the legacy plugin writes stock values straight to the database, bypassing Odoo’s stock movements. That single finding explains the overselling before any new code is written.

Estimating effort and risk

Codex drafts best, likely and worst-case estimates plus a risk register. For the example project, the register looks like this:

Risk Why it matters Planned response
▲Duplicate webhook events The same order could sync twice ✓Idempotency keys on every event
▲Race on the last item in stock Two stores sell one unit ✓Stock reservation in the job queue
▲Bundle SKU mapping Bundles break stock counts ✓Explicit bundle-to-component mapping
▲HKD rounding Totals differ between systems ✓Shared rounding rule, covered by tests

The tech lead then calibrates the estimates against historical project data.

Human checkpoint: the business analyst and tech lead sign off the spec, backlog and estimate. Architecture stays a human decision: in the example, the team chooses a job queue over direct webhook sync to handle retries and rate limits.

Estimated effort: 80 hours to 50 hours. The same discovery process supports larger enterprise software implementation projects.

Stage 2: Coding and development

Codex implements approved specs in small tasks, under the repository’s AGENTS.md rules and sandbox limits; a named developer reviews and owns every change.

Generating code from functional specifications

Each task covers one acceptance criterion and asks for the model, service, webhook controller and unit tests it needs.
Implement AC-07 (order sync on payment complete) following AGENTS.md. Use the existing queue job pattern in sync/jobs.py. Add unit tests. Do not modify the pricing module.

What makes a task like this work well:

  • One criterion per task, so the diff stays small enough to review properly.
  • A named pattern to follow, so new code matches the existing codebase.
  • An explicit no-go zone, so the agent leaves sensitive modules untouched.
  • Tests in the same task, so the change arrives with its own proof.

The same approach applies to storefront work in our WooCommerce development projects.

Refactoring legacy code and fixing bugs

Both follow a test-first order, so nothing changes without evidence.

Refactoring:

  1. Write characterisation tests that record how the legacy code behaves today.
  2. Ask Codex to improve the code in small steps.
  3. Rerun the tests after each step to catch unintended changes to business logic.

Bug fixing:

  1. Reproduce the bug in a failing test.
  2. Let Codex propose a fix.
  3. The developer confirms the root cause is resolved, not just the symptom.
  4. The full suite runs to rule out regressions.

Writing integration code and migration scripts

Component What Codex drafts What the developer checks
Database queries PostgreSQL stock reconciliation queries ✓ Query plans and performance
API clients REST clients with retries and exponential backoff ✓ API rate limits
Event handling Idempotency checks against duplicate processing ✓ Duplicate and out-of-order events
Migrations Data transformation scripts ✓ Dry run✓ Rollback plan✓ Reconciliation report

These checks matter most when storefronts connect to an Odoo ERP implementation. In the example, the 25,000-SKU migration is rehearsed three times, with record counts and values reconciled before go-live.

Understanding unfamiliar codebases

Developers new to a repository can ask Codex direct questions, for example:

  • “Where is wholesale pricing calculated?”
  • “What calls the stock sync job, and how often?”
  • “Which modules depend on the legacy plugin’s custom fields?”

The answers still need checking against the code, because AI can miss undocumented behaviour. METR’s study is a reminder that help is not automatic: on large repositories they already knew well, experienced developers were slower with AI tools (METR).

Where AI can go wrong: in a migration like this one, an AI could map wholesale prices to the wrong Odoo pricelist. Characterisation tests are what catch an error like that before the change is approved.

Human checkpoint: developers must be able to explain every diff they merge, and broad prompts are split into tasks with clear acceptance criteria.

Estimated effort: 420 hours to 290 hours.

Stage 3: Automated testing

Codex generates tests from acceptance criteria, suggests edge cases and analyses failures; QA engineers decide what to cover and check that every test asserts the right business behaviour.

Generating unit tests from requirements

Where the tests come from decides what they can catch:

Tests written from What they check Risk
The existing code That the code does what it already does ▲Existing bugs become “expected” behaviour
The approved requirements That the code does what the business asked for ✓Low, provided QA reviews the assertions

So the prompt deliberately keeps Codex away from the implementation:

Write pytest tests for AC-01 to AC-12 in specs/sync.md. Create at least one test per criterion. Do not read the implementation.

Automating end-to-end browser tests

With Playwright MCP, AI agents can explore a running web application and generate tests from natural-language instructions (Microsoft Developer Blogs). In the example, one end-to-end test follows a full transaction:

  1. A customer checks out on a storefront.
  2. Payment is confirmed.
  3. A webhook reaches the job queue.
  4. An order is created in Odoo.
  5. Stock updates on all three storefronts.

Stable test IDs replace selectors that depend on page text or layout, so tests survive design changes.

Covering edge cases and preventing regressions

Codex suggests uncommon scenarios; QA ranks them by business risk.

Test area Edge case
Payments Partial refunds
Product data Bundle SKU mapping
Inventory Two buyers competing for the last item
Webhooks Duplicate event delivery
Synchronisation Timeout mid-process
Pricing HKD rounding discrepancies

Every confirmed bug becomes a failing test before it is fixed, so it cannot quietly return.

Example estimate: regression testing drops from about three days of manual work to about four hours of automated runs per release.

Analysing test failures

Codex reads CI logs and sorts failures before a QA engineer confirms the diagnosis:

Failure type Typical sign Next step
Genuine defect Fails consistently after a code change Fix the code
Flaky test Passes and fails on reruns with no code change Stabilise the test
Outdated test Fails after an approved requirement change Update the assertion

Testing gains tend to be smaller than coding gains: in OpenAI’s Simplex case study, integration testing time fell 17%, against 70% for development (OpenAI). The aim is meaningful coverage, not the largest number of generated tests. Our QA testing and automation services apply this approach to client systems.

Estimated effort: 200 hours to 150 hours.

Stage 4: Code review and quality control

Every pull request passes an AI review, automated security scans and a senior developer’s approval. AI is never the final approver.

Why AI-generated code needs stricter review

Code that compiles and passes functional tests is not necessarily secure. Veracode’s 2026 GenAI Code Security Report (July 2026) puts numbers on the gap:

  • 56% average security pass rate across more than 100 models, almost unchanged from the 2025 edition (Veracode).
  • 51% vs 52%: coding-specialised models were no more secure than general-purpose ones (SD Times).
  • 63% to 30%: pass rates ranged from Python down to Java.

The 2025 edition had reported security flaws in 45% of tasks and a Java failure rate above 70% (SD Times). We therefore treat AI-generated code as untrusted until it has passed review and security checks.

Our code review pipeline

  1. Developer self-review. The developer asks Codex to inspect the changes before opening a pull request.
  2. Codex pull request review. Codex reviews the pull request on GitHub and flags P0 and P1 issues.
  3. Automated security scanning. Static application security testing (SAST) and software composition analysis (SCA) run in the CI pipeline.
  4. Senior developer approval. A senior developer reviews the findings and approves the merge; branch protection enforces this.

What the review checks

Review area Example issues
Correctness Null handling, unhandled API errors
Security Unverified webhook signatures, hard-coded secrets, SQL injection, XSS
Performance N+1 queries during stock synchronisation
Coding standards Breaches of the repository rules in AGENTS.md
Maintainability Duplicated field-mapping functions

Turning AI findings into better human reviews

Reviewers triage each AI comment (fix, dismiss or discuss) and spend their own time on architecture, business logic and the impact of a change across connected systems. Two traps need active countermeasures:

Trap Countermeasure
▲Alert fatigue from too many low-value comments ✓Tune review rules in AGENTS.md to high-impact findings
▲Rubber-stamping AI-reviewed changes ✓Reviewers record their reasoning on high-risk changes

We cover roles and ratios in our guide to QA team structure.

Estimated effort: 80 hours to 60 hours, with every pull request scanned.

Stage 5: Documentation and knowledge sharing

Codex drafts documentation, explains legacy business logic and answers new developers’ questions, so knowledge does not sit with one person; developers review and approve all documentation.

Generating technical and API documentation

Document What it covers When it is updated
API reference (e.g. OpenAPI) Endpoints, parameters, response schemas, error codes Same pull request as the API change
README and setup guide Project structure, dependencies, environment setup When setup steps change
Operational runbooks How to investigate and rerun a failed sync After each incident or process change

Explaining legacy business logic

Codex traces business rules scattered across the codebase and rewrites them in plain language. In the example, the wholesale pricing tiers hidden in the old plugin become a rule table the client’s business owner can check line by line against current policy. That review is where outdated rules surface, before they are rebuilt into the new integration.

Human checkpoint: the business owner, not the developer, confirms that each documented rule still reflects how the business works.

Speeding up onboarding and reducing key-person risk

A Codex-generated codebase tour gives new developers a starting map:

  • Core modules and what each is responsible for
  • Key data flows and system integrations
  • Important configuration files and development commands

From there, new team members ask repository-specific questions instead of relying entirely on senior colleagues. In the example, time to a first meaningful pull request is estimated to fall from about two weeks to about four days.

Architecture decisions stay in Architecture Decision Records written by people, with Codex helping to keep summaries current. This matters most when work is shared with offshore software developers across locations.

Common pitfall: AI-generated documentation can sound right while describing outdated behaviour, so it is reviewed alongside the code.

Estimated effort: 100 hours to 70 hours.

Limitations and risks of AI-assisted development

AI-generated code can be wrong, insecure or built on invented assumptions, so every output needs the same checks as human-written code, or stricter ones.

Risk What can go wrong Mitigation
▲Hallucinations and incorrect suggestions Inaccurate code or explanations due to AI hallucinations and bias (DLA Piper) ✓Verify outputs against requirements and actual system behaviour
▲Security vulnerabilities AI-generated code averaged a 56% security pass rate in Veracode’s 2026 benchmark ✓Code review, SAST and SCA scans, security testing
▲Uncertain productivity Experienced developers were 19% slower with AI tools in METR’s study ✓Measure net delivery time, including rework
▲Data privacy and confidentiality Source code or customer data sent to cloud AI tools may expose confidential information ✓Classify data; use approved tools and accounts only
▲Intellectual property and licensing Unclear ownership of AI-generated code; open-source licence conflicts ✓Define ownership in contracts; check licence compliance
▲Over-reliance and code quality Accepting code without understanding it builds technical debt and erodes skills ✓Code-reading reviews; named developer accountability

On intellectual property, Hong Kong has no AI-specific copyright exception yet. The Copyright (Amendment) Bill 2025, which proposed a text and data mining exception, was removed from the Legislative Council’s agenda, and the government is issuing operational guidelines first.

AI also has clear limits in what it should decide. System design, technology choices and trade-offs depend on business and engineering context that AI cannot reliably weigh, and complex business logic needs developers and business owners to confirm that the implementation matches real rules.

AI Governance in Hong Kong: PCPD, DPO and HKMA Guidance

Enterprises should expect an AI-assisted development partner to work within Hong Kong’s privacy and AI guidance, with documented controls and a named person accountable for every change.

Hong Kong has no AI-specific law; existing laws such as the Personal Data (Privacy) Ordinance apply, supported by non-binding guidance.

  • PCPD. The Privacy Commissioner published its Checklist on Guidelines for the Use of Generative AI by Employees on 31 March 2025 (PCPD), to be read with its AI Model Personal Data Protection Framework of June 2024 (Bird & Bird). The checklist is not binding, but it is tied to the binding ordinance and shows what the PCPD expects organisations to have in place (Fisher Phillips). Fewer than 30% of Hong Kong organisations had a generative AI policy when it was issued (Lewis Silkin).
  • Digital Policy Office. The Hong Kong Generative AI Technical and Application Guideline was released on 15 April 2025 and covers risks including data leakage, model bias and errors (GovHK). The current version is 1.1, dated December 2025, published on the Digital Policy Office website.
  • Financial services. HKMA guidance holds the boards of financial institutions accountable for AI-driven decisions (SCMP). On 5 March 2026, the HKMA, SFC, Insurance Authority and MPFA launched the GenA.I. Sandbox++ to test use cases under supervisory guidance (HKMA).

What this means for Arestós clients

For clients, AI-assisted development means shorter timelines and lower cost on routine work, with a named engineer still accountable for every release.

The goal is not simply to generate code faster. It is to deliver software more efficiently while keeping clear ownership, quality standards and human oversight. You can see the kinds of systems we build in our recent projects.

Frequently Asked Questions

1. Is AI-assisted development secure for enterprise projects?

It can be, when security is built into the workflow: approved tools and accounts, no secrets or personal data in prompts, sandboxed agents, SAST and SCA scans on every pull request, and a named engineer approving each merge. Without those controls, AI adds risk rather than reducing it.

2. What are the best AI tools for software development?

The right mix covers four jobs: a coding agent (such as OpenAI Codex, GitHub Copilot or Claude Code), AI code review on pull requests, AI-assisted test generation (for example with Playwright), and conventional security scanning. The tool matters less than the workflow and review gates around it.

3. Does AI-assisted software development reduce development costs?

It reduces effort on routine work, but results vary. OpenAI’s vendor-published Simplex case study reported 70% less development time per screen, while METR found experienced developers were 19% slower on familiar codebases. We report net savings for each project.

4. Can AI replace software developers?

No. AI speeds up specific tasks, but judgement about requirements, architecture, business logic, security and accountability stays with people.

5. How does OpenAI Codex support the software development process?

In our workflow, Codex drafts specs and impact analyses, generates and refactors code, writes tests, reviews every pull request and drafts documentation, following each repository’s AGENTS.md rules. A developer reviews every output.

6. How should regulated Hong Kong companies approach AI-assisted development?

Align internal policies with the PCPD’s generative AI checklist and the Digital Policy Office’s generative AI guideline. Financial institutions should also follow HKMA and SFC expectations on accountability and risk management.

7. How do we measure whether it is working?

Track net time saved, rework rate, defect escape rate and pull request cycle time, not how fast the team feels. In METR’s study, developers believed they were 20% faster even though they had been slowed down.

Conclusion

AI-assisted software development delivers its value when AI takes on repetitive, verifiable work and people keep the decisions. In the retail example, the estimate drops from 12 weeks to 9. The time comes from specs, tests, first-pass reviews and documentation, while architecture, business rules and approval stay with engineers.

With only 3% of Hong Kong companies having fully integrated AI into their workflows, a disciplined approach is still a real advantage.

Planning a web, e-commerce or ERP project? Book a free consultation on AI-assisted web and software development with an Arestós tech lead, and see where AI fits in your project and where it does not.

Start Innovating Your Business Now! Want to get FREE Consultancy and Quick Estimation?
Reach us at +852 3796 0101 or email us