Zaman TauhidTechnical Lead & Software Architect
Zaman Tauhid

ResumeGitHubLinkedIn

Technical Lead & Software Architect · Dhaka, Bangladesh

AI-native development

An AI-native development workflow that keeps you in control

A practical approach to specifications, context, bounded implementation, and verification when building software with coding agents.

An effective AI-native development workflow connects the requirement to the implementation and the evidence that the implementation works. The model can help throughout that process. The engineer remains responsible for deciding what the system should do and determining whether the result is correct.

My approach is to make that chain explicit: define the outcome, gather the relevant context, bound the task, inspect the change, and verify the behavior. Each step produces something the next step can use.

This guide describes that approach through an illustrative feature: adding a stock-transfer operation to an inventory application. It is a design example, not a benchmark or a report of a particular production implementation.

Begin with observable behavior

“Add stock transfers” leaves most of the product undecided. Can a transfer be partially fulfilled? When does stock leave the source? Who can approve it? What happens when the destination location is disabled?

A useful specification describes what a user can do and what the system must preserve. For a small first version, the acceptance criteria might be:

  • An authorized operator selects a source, destination, product, and quantity.
  • The source and destination must be different active locations.
  • A confirmed transfer reduces available stock at the source and increases it at the destination atomically.
  • Insufficient stock produces a clear error and leaves both balances unchanged.
  • Repeating the same confirmed request does not apply the transfer twice.
  • The system records the actor and the resulting movement for later inspection.

These requirements expose the difficult parts before code exists. Authorization, concurrent updates, retries, and audit history are now part of the work rather than assumptions hidden inside a generated handler.

Gather context with a purpose

Repository context should answer questions. Where is authorization enforced? Which service owns stock mutations? How are database transactions handled? Which tests describe similar operations?

Start by locating the implementation paths that matter. Ask the development agent to explain its findings with references to the code. Review that explanation before using it as the basis for a change.

A compact task brief can then connect the requirement to the actual repository:

text
Outcome
Add a confirmed stock-transfer operation.

Existing conventions to inspect
- The stock-adjustment service and its transaction boundaries
- Location authorization and active-location checks
- The movement ledger and existing inventory tests

Constraints
- Reuse the current stock mutation pathway
- Preserve existing adjustment behavior
- Keep both balance changes in one transaction

Verification
- Successful transfer
- Insufficient stock
- Unauthorized source or destination
- Repeated request
- Concurrent changes to the source balance

This is a brief for investigation and implementation. It is not permission to assume that a named service exists. The agent should establish the real paths and surface any mismatch between the brief and the codebase.

Give implementation a bounded scope

A task should be small enough to review as a coherent change. “Modernize the entire inventory module” creates too many moving parts to evaluate confidently.

For the transfer example, one increment could establish the domain operation and its tests. Another could connect it to the application endpoint. A third could implement the user interface and its error states.

The boundaries should follow useful behavior, not arbitrary file counts. A change across several files can still be tightly scoped when those files implement one operation. A one-file change can be dangerously broad if it alters shared behavior throughout the application.

Ask the agent to identify assumptions before implementation. If it discovers that the existing stock service cannot support the required atomic update, that is an architecture decision to resolve, not a detail to hide behind a new abstraction.

Keep the diff understandable

Read the change as an engineer responsible for maintaining it. Check whether the implementation follows the ownership boundaries identified during investigation. Look for duplicate validation, additional mutation paths, unnecessary dependencies, and behavior unrelated to the task.

Generated code can be locally plausible while conflicting with a larger convention. A new authorization helper may look reasonable and still bypass a rule already enforced elsewhere. A convenient cache may obscure the source of truth for inventory.

Ask for explanations when a design choice is unclear, then verify those explanations against the code. The explanation is an aid to review. The implementation remains the evidence.

Verify against independent criteria

Tests are most useful when they derive from the requirements rather than reproducing the implementation. The stock-transfer test should establish the before-and-after balances, movement records, and failure behavior. It should not simply assert that a private helper was called.

For concurrent work, identify what the system promises. A successful happy-path test says little about two transfers competing for the same stock. The test environment and the database behavior need to represent the concern being evaluated.

The user interface needs its own checks: can the user understand the form, recognize an error, and tell when the transfer completed? What happens when the response is delayed? Does the same workflow work with a keyboard and on a small screen?

Verification should produce a short record of what was checked and what remains uncertain. “All tests pass” is useful only when the tests cover the claim being made.

Manage context as the work evolves

Long tasks accumulate decisions, discoveries, and abandoned approaches. Keep a concise record of the current requirement, important decisions, completed work, and unresolved questions.

That record should point to the source of truth rather than duplicating the entire repository. When an interface changes, update the relevant documentation and explain the migration. When a concern is resolved, remove it from the open-question list.

Parallel agents can help when their responsibilities are independent and the integration boundary is clear. They also introduce coordination work. Shared state, overlapping edits, and incompatible assumptions still need an accountable owner.

Treat delivery as part of development

A feature can be correct in isolation and fail during release. Consider configuration, migrations, existing data, background workers, observability, and rollback before declaring the work complete.

For the example transfer feature, a migration might add an idempotency constraint or a new movement type. Existing reporting code may need to understand that type. A deployment plan should account for those dependencies.

AI can help inspect these relationships and prepare checks. The acceptance standard stays the same: a change is ready when its behavior and operational requirements are understood well enough for the intended release.

The practical advantage of this workflow is continuity. Requirements guide implementation, implementation remains reviewable, and verification tests the promises made at the start.

Put the ideas into practice.

Work through your development process, architecture, or next engineering challenge with me.

Explore one-to-one mentorship