AI-assisted development

AI speeds up development. Humans still design the system.

AI can draft code, tests and content, but it does not own system design, scalability, feasibility, security or business trade-offs. My proposed workflow uses AI for repetitive drafting while a human remains responsible for architecture, review and what is released. The approach still needs to fit your business.

  • 11 min read
  • Last updated: 2026-11-21
Illustration: AI drafts code while a human reviews and approves the architecture blueprint.

The honest take

A draft is not a complete system.

AI tools can produce components, test cases, copy and boilerplate quickly. They can also produce confident mistakes, assume constraints that were never agreed and optimise a fragment while overlooking the wider system.

A website connects publishing, traffic, inventory, payments, external services and people. A working demo does not establish that those boundaries are safe or maintainable. Someone still needs to decide what should be built, what can fail and who owns the result.

The benefits

Where AI helps with the work.

  • A useful first draft

    Components, templates, queries and boilerplate are good starting points for assisted drafting. A draft becomes usable only after it is checked against the actual framework, data model and repository conventions.

  • Explore before committing

    An assistant can outline several implementation routes and make their assumptions visible. Comparing them is useful; choosing one still depends on the team's constraints, platform limits and maintenance capacity.

  • More questions for the test plan

    Generated test ideas can expose missing inputs, failure paths and boundary conditions. The engineer must still decide whether the assertions represent the requirement rather than merely repeating the implementation.

  • Read unfamiliar code

    AI can help summarise a legacy module or trace likely dependencies. Those explanations need checking against the code and observed behaviour before they become documentation or a migration plan.

  • Repetitive changes under review

    Mechanical refactors and repeated migration steps can be drafted consistently. Small batches, a reviewable diff and checks against representative records keep a broad change from hiding a repeated mistake.

  • Content and metadata scaffolding

    Page structures, headings and structured-data drafts can help organise a content workflow. Claims, canonical URLs, entity details and the actual search intent still need editorial verification.

  • Protect time for judgement

    Reducing repetitive drafting can leave room for architecture, review and measurement. That is an intended use of the workflow, not a promise that every project will take less time or achieve a particular result.

The limits

Risks that a good demo can hide.

Plausible but wrong code

A generated API call can look familiar while using an unavailable method or an outdated convention.

How I manage it: Check the installed documentation and the real execution path. Review the diff and test the expected behaviour before accepting it.

Security gaps

Input handling, authorisation, secrets and dependencies can be wrong even when the happy path works.

How I manage it: Review trust boundaries and access checks, scan for exposed secrets and examine dependency changes. A passing build is not a security assessment.

Missing business context

An assistant does not automatically know how orders, publishing approvals or customer support work in your organisation.

How I manage it: Agree requirements and architecture first. Keep business rules explicit rather than expecting a prompt to supply missing decisions.

Duplicated or inconsistent code

Separate drafts may solve the same problem differently and leave several versions to maintain.

How I manage it: Use shared conventions, linting and review to identify duplication. Keep a clear owner for the underlying behaviour.

Performance blind spots

A component can look correct while adding expensive scripts, repeated data calls or oversized assets.

How I manage it: Measure loading and rendering, inspect the data path and set delivery budgets. Optimise the observed bottleneck rather than the appearance of the code.

Demo-only accessibility

A pointer-driven demo can hide keyboard traps, unreadable contrast and layouts that overflow on a phone.

How I manage it: Test keyboard paths, responsive states and assistive semantics. Check reduced-motion behaviour and the devices and browsers agreed for the project.

Privacy and licensing

Prompts, generated content and dependencies need the same care as other third-party inputs.

How I manage it: Use only approved inputs, keep client secrets and private records out of prompts, review licences and follow the client agreement.

Code without an owner

Shipping a change that nobody can explain makes recovery and maintenance harder.

How I manage it: The human owner must understand the accepted code and its failure paths. Document decisions and agree support responsibilities at handover.

AI drafts / human decides

A human is still needed for the decision.

AI drafts

System design: possible inputs

AI can sketch monolithic, headless or hybrid options and suggest where state or service boundaries might sit.

Human decides

The decision and its owner

A human chooses the architecture against the publishing workflow, commerce rules and team capacity. That includes deciding where state belongs and how services communicate. A simpler theme or a focused custom module may be a better answer than another application.

System design in detail

Design the boundaries before the components.

Illustrative architecture flow: Visitor → CDN / edge → Application → API layer → Commerce backend → Database / queue → External services. This is a reference layout, not a client implementation or a performance result.

Visitor

The customer arrives on a device, network and browser you do not control. The first useful content and the primary action must remain understandable when assets or external services are slow.

CDN and edge

Cloudflare or another delivery layer can handle suitable public assets and selected request rules. Personalised responses, carts and authenticated content need explicit boundaries so a cache cannot expose the wrong data.

Application

A Liquid theme, Hydrogen storefront or Next.js application turns source data into the customer experience. Choose the application model around the required interaction and the team's ability to run it.

API boundary

This layer defines validation, credentials, errors and what the browser is allowed to request. Without a clear boundary, external systems can leak into presentation code and make failures difficult to isolate.

Commerce backend

Shopify or WooCommerce remains responsible for the agreed product, order and operational records. The frontend must respect that ownership instead of maintaining an unexplained second version of stock or order state.

Database and background work

Queries, scheduled tasks and queues handle different kinds of work. A queue can buffer suitable writes, but retries, duplicate handling and recovery still need design and visibility.

External services

Payments, courier systems and CRMs bring their own availability, response formats and limits. Plan timeouts, status reporting and a way to investigate a failed handoff rather than assuming every response succeeds.

How scope informs pricing · Explore your project scope

A feasibility check with a useful output

  1. Goals and constraints

    Ask what must improve, who uses the system and what must stay. Produce an agreed problem statement and clear boundaries.

  2. Volume and growth assumptions

    Ask about traffic patterns, catalogue growth and campaign spikes. Produce assumptions that can be checked rather than a capacity promise.

  3. Platform and API limits

    Inspect supported APIs, licence terms and operational access. Record the limits that rule an option in or out.

  4. Risks and failure modes

    Ask what happens when payments, publishing or external connections fail. Produce a recovery and ownership checklist.

  5. Compare build, buy and extend

    Compare a theme extension, existing tools and custom development. Make ongoing complexity visible alongside the initial implementation.

  6. Recommend with trade-offs

    Explain the preferred route and the alternative that was rejected. Produce a scope the owner can question, approve and maintain.

Scalability checklist

  • Public and personalised cache boundaries
  • Image sizes and asset delivery
  • Database growth and query load
  • Background jobs and retry behaviour
  • Third-party rate limits
  • Monitoring and useful alerts
  • A tested rollback path
  • Operating cost as usage grows
  • Ownership and documentation

Which approach fits?

ApproachBest whenTrade-off

Best whenA Shopify theme can be extended to fit the buying journey.

Trade-offTheme and checkout boundaries still apply.

Best whenA bespoke Shopify frontend justifies a separate application.

Trade-offAdds deployment, integration and maintenance responsibilities.

Best whenContent and commerce need custom presentation across API sources.

Trade-offPreviews, caching and publishing need explicit engineering.

Best whenContent-heavy sites and custom commerce logic belong together.

Trade-offCustom code and plugins need an ownership and update plan.

Conversion and UX

Make the journey understandable and measurable.

Illustrative funnel flow: Visit → Product → Cart → Checkout → Order. This is a reference layout, not a client implementation or a performance result.
  • Speed and Core Web Vitals

    Measure loading, responsiveness and layout stability. Prioritise the delivery or rendering issue that affects the actual journey.

  • Mobile-first interaction

    Make content, controls and tap targets work in the narrow layout first. A desktop design squeezed into a phone is not a usable mobile checkout.

  • Product and offer clarity

    Structure the information the customer needs to choose a product or offer. Templates and data fields should support that explanation rather than hide it in a decorative layout.

  • Checkout friction

    Review fields, delivery options, payment paths and error messages. Keep validation and recovery understandable instead of silently dropping a customer's input.

  • Trust signals

    Present real policies, product information and genuine proof where they help a decision. Do not invent testimonials, badges or urgency to fill a layout.

  • Search and navigation

    Give products and content a predictable structure and useful empty states. Check the path from a query or category to the required next action.

  • Tracking and events

    Define GTM and conversion events around actions the platforms can actually expose. Test the measurement path before using it to evaluate a campaign or interface change.

  • Experiment-ready structure

    Keep changes small and components understandable so a hypothesis can be tested. Feature flags or experiment hooks need ownership and a removal plan after the test.

A conversion investigation, not a guarantee

  1. Measure

    Check that the events describe the buying journey before using them as evidence.

  2. Find friction

    Look for unclear choices, broken interactions and unnecessary effort in that journey.

  3. Form a hypothesis

    Describe the specific obstacle and why a proposed change might address it.

  4. Build the smallest change

    Limit the implementation to what is needed to examine that hypothesis.

  5. Test

    Check the affected flow, tracking, devices and failure states before release.

  6. Learn

    Review the evidence and decide whether to keep, adjust or reverse the change.

I do not guarantee conversion lifts; the goal is to remove friction and make results measurable.

Prepare a launch review

Responsive engineering

Work with the device, not around it.

Illustration: the same content reorganises across desktop, tablet and phone frames.
  • Use fluid grids and breakpoints based on the content, not just device labels.
  • Keep touch targets usable and do not hide essential actions behind hover.
  • Size images for the layout, reserve their dimensions and defer non-critical assets.
  • Measure delivery and rendering on the devices and connections that matter to the project.
  • Support keyboard navigation, visible focus and meaningful screen-reader labels.
  • Test the agreed browsers and real devices alongside automated checks.
  • Respect reduced-motion preferences and keep a usable static state.

How I work with AI

Human direction, reviewable changes.

  1. A human defines the business problem, audience and constraints before drafting implementation.

  2. A human compares the options. AI can help expose questions and alternatives, but it does not approve the architecture.

  3. AI drafts focused changes under direction. Work stays in reviewable units with clear conventions and a defined result.

  4. A human reads the change, checks the assumptions and validates the affected behaviour and trust boundaries.

  5. Measure relevant paths, inspect mobile layouts and check keyboard and reduced-motion behaviour.

  6. Approve the release and prepare documentation, deployment access and an agreed support boundary.

Illustrative workflow flow: Human brief → Architecture → AI drafts → Human review → Measured QA → Launch & own. This is a reference layout, not a client implementation or a performance result.

Brief and goals

Rules I follow

  • No client secrets or private records in prompts.
  • Review every accepted AI-written change.
  • Run the relevant checks before merging.
  • Document decisions and handover responsibilities.

Real project context

Where engineering decisions show up.

These projects illustrate architecture, integration and custom data work. Their inclusion does not claim that AI was used on them.

Questions

What assistance does—and does not—change.

Can AI replace a developer?

AI can draft parts of an implementation, but it does not accept responsibility for the complete system. Architecture, verification and operational decisions still need an accountable owner.

Is AI-written code safe for my store?

Safety depends on the accepted code and its review, not the label used to produce it. Check access control, validation, dependencies and the affected customer and admin journeys before release.

Do you use AI on client projects?

The proposed workflow uses assisted drafting with human architecture and review. Any actual use needs to fit the client agreement, approved inputs and the project's confidentiality requirements; the agreed scope should make those boundaries explicit.

Will AI make my project cheaper or faster?

It may reduce some repetitive drafting, while review and integration still take work. Scope, platform constraints and the quality of the existing system determine the effort; there is no blanket cost or delivery promise.

Who owns the code?

Ownership and licences should be explicit in the project agreement. The handover should identify custom work, third-party dependencies, deployment access and any continuing responsibilities.

How do you keep my data private?

The proposed rule is to keep client secrets and private records out of prompts and use only approved inputs. Tool access, retention and the client agreement must be reviewed before any AI-assisted workflow is used.

What does human review catch?

Review looks for mismatched requirements, unsafe assumptions, duplicated logic and behaviour that tests may not cover. It also checks how the change fits the wider publishing, commerce and operational system.

Can AI do conversion optimisation?

It can suggest ideas and interface variants. A useful conversion programme still needs a measurable hypothesis, reliable events and evidence from real customer behaviour.

What if my site was already built with AI tools?

Start with the actual code, deployment setup and the journeys that matter. A review can identify maintainability, performance and integration concerns without assuming the entire site needs replacing.

How do we start?

Share the current site or the planned build and the main constraint. Request a written audit first, or send a project brief when you already know the implementation scope.

Written by Abdullah Ghaffar

Commerce and CMS engineering.

Abdullah works from Lahore with clients worldwide across Shopify, WordPress, WooCommerce and headless systems.

About Abdullah and his work

A practical next step

Review the constraint before choosing the build.

Start with written findings, or send a brief when the implementation scope is already clear.

Get a free website auditStart a project