AI-Powered SDLC: How We Build Software with Codex and Claude

Our Principles

AI does the heavy lifting. People stay in charge.

AI coding agents are now genuinely useful across the whole lifecycle. Used carelessly, they also produce confident, plausible and wrong code. These four rules keep the speed and remove the risk.

A human owns every change

AI drafts; an engineer reviews, understands and approves. Nothing reaches production because “the AI said so”.

Context before prompts

Output is only as good as what the AI knows about your system. We invest in context the same way we invest in documentation.

Tests are the referee

AI-written code has to pass the same automated tests, linting and security checks as any other code, in the same CI pipeline.

Your code stays yours

Client code and data are handled under your NDA and your rules, including where AI tools may and may not be used.

Stage by Stage

AI across the whole lifecycle

For each stage: where AI helps, and what a person on our team always owns.

Discovery & requirements

AI helps: Turning meeting notes and existing documents into draft user stories, acceptance criteria and open questions to raise with you.
People own: Understanding your business, agreeing scope and priorities with you, and signing off the backlog.

Design & architecture

AI helps: Mapping an unfamiliar codebase, comparing design options, drafting architecture decision records, API contracts and threat-model checklists.
People own: The architecture decision itself, trade-offs on cost, security and scale, and your approval before we build.

Development

AI helps: Implementing well-specified tickets, boilerplate, refactors, dependency upgrades and migrations, each delivered as a reviewable pull request.
People own: Task breakdown, tricky business logic, code review and the decision to merge.

Testing & QA

AI helps: Generating unit and end-to-end test cases from acceptance criteria, filling coverage gaps, suggesting edge cases and triaging flaky tests.
People own: The test strategy, exploratory testing, and deciding whether a release is good enough. See AI-powered QA.

Review & security

AI helps: A first-pass review of every pull request for bugs, missing tests, risky patterns and secrets, before a senior engineer looks at it.
People own: The final review, security sign-off and anything touching authentication, payments or personal data.

Release & DevOps

AI helps: Writing and reviewing CI/CD pipelines and Terraform, drafting release notes, and explaining failed builds.
People own: Production access, change approval and rollback decisions. See our DevOps & Cloud services.

Operate & improve

AI helps: Summarising logs and incidents, drafting post-mortems, keeping documentation in step with the code.
People own: Incident response, root-cause conclusions and what we change next.

The same agile rhythm you already know

AI fits inside our normal delivery process: two-week sprints, regular demos and your sign-off at each milestone. You see the same visibility and accountability, with more tests and better documentation along the way.

Context Management

The part most teams get wrong

An AI agent only knows what is in its context: the instructions, files, tickets and conversation it can see at that moment. Give it too little and it guesses. Give it too much and the important parts get lost.

Context windows are large today, but they are not unlimited, and quality drops as they fill with irrelevant material. So we manage context deliberately, as an engineering practice.

1. Instruction files in every repository

Each project has a short, version-controlled instruction file that both tools read at the start of every task: AGENTS.md for Codex and CLAUDE.md for Claude Code. It records the stack, how to build and test, coding conventions and hard rules. It is reviewed in pull requests like any other code, so the AI’s understanding of the project improves as the project does.

# Project context for AI assistants (example)
## Stack
- API: Python 3.12, FastAPI, PostgreSQL 16
- Web: React + TypeScript
## Commands
- Tests: make test    Lint: make lint
## Conventions
- Every API change updates the OpenAPI spec and adds tests
- Configuration comes from environment variables, never from code
## Never
- Edit migrations that have already shipped
- Add a dependency without explaining why in the PR

2. A spec before a prompt

AI works from the ticket, not from memory. Every task starts with a clear description, acceptance criteria and links to the relevant design notes or API contract. If we can’t write the spec, the task isn’t ready for AI, or for a person.

3. One task, one session

Long conversations drift: early instructions get diluted and old assumptions linger. We keep sessions focused on a single task and start fresh for the next one. When a session does get long, we summarise what matters and continue from the summary rather than dragging the whole history along.

4. Curate, don’t dump

We point the AI at the modules, interfaces and tests that matter for the task instead of pasting entire repositories or thousands of log lines. Secrets, credentials and personal data are never part of the context.

5. Decisions live outside the chat

Anything worth remembering goes somewhere durable: architecture decision records, pull-request descriptions and short hand-off notes at the end of each AI-assisted task. The next engineer, or the next AI session, starts from that record, not from a chat history.

6. Connect tools deliberately

Agents can connect to issue trackers, documentation and other systems (for example through the Model Context Protocol). We only connect what a task needs, with the least access that works, and only where the client has agreed.

7. Let tests close the loop

Good context tells the AI what to build; tests tell it whether it worked. Agents run the project’s tests and linters as part of each task, and CI stays the single source of truth.

Why it matters to you: well-managed context is the difference between AI that saves days and AI that creates rework. It is also why our AI-assisted work comes with better documentation: the context we write for the AI is useful to your team too.

Our Tools

The AI we use, and where

For writing code we use Codex (from OpenAI) and Claude (from Anthropic), picking per task. For AI features inside the products we build, such as HRxAI, we use Google’s Gemini models.

Codex

OpenAI · coding agent

Our choice for well-scoped, independent tasks that can run in parallel in isolated environments, each ending in a pull request.

Adding tests to existing modules and closing coverage gaps
Small refactors, dependency upgrades and clean-ups across a codebase
Fixing clearly described bugs with a failing test to start from
Several tickets worked on at once, then reviewed one by one

Claude

Anthropic · coding agent

Our choice for work that needs a lot of context and careful reasoning, in the terminal and IDE with Claude Code.

Exploring an unfamiliar or legacy codebase and explaining how it works
Planning changes that touch many files before any code is written
First-pass reviews of pull requests, and architecture and design discussions
Writing and updating technical documentation and hand-off notes

Gemini

Google · in our products

The model behind the AI features in systems we build, including our hiring platform HRxAI. Product AI has to be reliable, affordable at scale and careful with users’ data.

AI features in HRxAI, our AI hiring platform
Reading and understanding documents such as resumes and job descriptions
Tested against real examples before a feature ships, and monitored after
The same review, context and data rules as our coding work

Governance

Guardrails that protect your project

Confidentiality

We use business-grade AI accounts configured so your code and data are not used to train models, and we follow your NDA and any tool restrictions you set.

Reviewed, traceable changes

AI-assisted changes go through the same pull-request review as everything else, so there is always a named reviewer and a clear history of what changed and why.

No secrets in context

Credentials, production data and personal data are kept out of prompts. Automated secret scanning runs in the pipeline as a backstop.

Licences & ownership

We check new dependencies and generated code for licence issues. The code we deliver is yours under your contract, however it was written.

PDPA-aware

Where a project processes personal data, we design and test with Thailand’s PDPA in mind and keep real personal data out of AI tools.

Your rules, per project

Some clients want AI everywhere, some only for tests and docs, some not at all. We agree it with you at the start and stick to it.

FAQ

Questions clients ask us

Does AI write all of your code?

No. AI drafts a large share of routine work such as tests, boilerplate, refactors and documentation, and helps on harder problems. Engineers design the solution, write the tricky parts, review everything and decide what ships.

Is the quality lower than hand-written code?

It has to meet the same bar: the same code review, tests, linting and security checks in the same CI pipeline. In practice AI tends to increase test coverage and documentation, because they become cheap to produce.

Is our code used to train AI models?

We use business-grade accounts configured not to train on customer content, and we can restrict tools further under your NDA. Ask us for the details for your project.

Who owns the code you deliver?

You do, as set out in your contract, whether a line was typed by an engineer or drafted by an AI tool and reviewed by one.

Can we choose not to use AI on our project?

Yes. We agree the rules at the start of every engagement, from full AI-assisted delivery to none at all, and follow them.

Does this make projects cheaper?

It usually makes teams faster on routine work, which leaves more time for the parts that need experience. How that translates into cost depends on the project, so we discuss it openly when we scope your work.

Which AI models do you use inside the products you build?

For AI features inside products, such as HRxAI, we build on Google’s Gemini models. If your project has specific needs, for example where data is stored or cost targets, we’ll discuss the options with you.

Want AI-assisted delivery done properly?

Tell us about your project, or about your own team’s AI adoption. We’re happy to share what works, including how to set up context management in your repositories.

Book a free consultation Read: AI in software development