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.
AI drafts
Scalability: possible inputs
AI can draft load scenarios, cache diagrams and questions about traffic, background jobs and external limits.
Human decides
The decision and its owner
An engineer checks the assumptions against campaign patterns, data growth and the platforms involved. Cache boundaries, queues and third-party rate limits need deliberate failure behaviour. Capacity decisions should be supported by measurement rather than a diagram labelled scalable.
AI drafts
Feasibility: possible inputs
AI can compare build, buy and extend options and list likely constraints to investigate.
Human decides
The decision and its owner
A human checks licence terms, API capabilities, delivery risk and the maintenance burden. The decision includes whether the feature should exist at all. A smaller change may meet the goal without committing the team to a complex rebuild.
AI drafts
Data and integrations: possible inputs
AI can outline payloads, mappings and candidate webhook handlers.
Human decides
The decision and its owner
Someone must decide which system owns each record and how duplicate, delayed or failed events are handled. Payments, courier bookings, CRM records and inventory updates need clear recovery paths. Idempotency and reconciliation are requirements to design and test, not labels to add afterwards.
AI drafts
Security and privacy: possible inputs
AI can suggest a checklist or help explain a code path that handles sensitive inputs.
Human decides
The decision and its owner
A human reviews access control, validation and the data exposed at each boundary. Payment and personal-data flows need the applicable platform controls and agreements. AI assistance does not replace a qualified security or compliance review where one is required.
AI drafts
Performance and reliability: possible inputs
AI can help interpret traces and propose possible code or asset changes.
Human decides
The decision and its owner
An engineer separates network, origin, data and browser work using measured evidence. Monitoring, rollback and graceful failure need owners and practical procedures. A faster isolated component does not prove that the complete journey is reliable.
AI drafts
UX and conversion: possible inputs
AI can draft interface variants and hypotheses about where a visitor may encounter friction.
Human decides
The decision and its owner
A human decides what to test using the product, offer and observed behaviour. The team needs a dependable event plan before judging a change. Visual preference or generated copy is not evidence of a conversion improvement.
AI drafts
Ownership: possible inputs
AI can assist with release notes, test summaries and handover drafts.
Human decides
The decision and its owner
A responsible person approves the release, explains the trade-offs and can investigate a failure. The code, deployment access and support arrangements need a clear handover. No availability or maintenance commitment should be assumed without an agreement.
System design in detail
Design the boundaries before the components.
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
Goals and constraints
Ask what must improve, who uses the system and what must stay. Produce an agreed problem statement and clear boundaries.
Volume and growth assumptions
Ask about traffic patterns, catalogue growth and campaign spikes. Produce assumptions that can be checked rather than a capacity promise.
Platform and API limits
Inspect supported APIs, licence terms and operational access. Record the limits that rule an option in or out.
Risks and failure modes
Ask what happens when payments, publishing or external connections fail. Produce a recovery and ownership checklist.
Compare build, buy and extend
Compare a theme extension, existing tools and custom development. Make ongoing complexity visible alongside the initial implementation.
Recommend with trade-offs
Explain the preferred route and the alternative that was rejected. Produce a scope the owner can question, approve and maintain.
Get a feasibility and speed review
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?
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.
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
Measure
Check that the events describe the buying journey before using them as evidence.
Find friction
Look for unclear choices, broken interactions and unnecessary effort in that journey.
Form a hypothesis
Describe the specific obstacle and why a proposed change might address it.
Build the smallest change
Limit the implementation to what is needed to examine that hypothesis.
Test
Check the affected flow, tracking, devices and failure states before release.
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.
Want this review on your own site? Request a free website audit
Responsive engineering
Work with the device, not around it.
- 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.
A human defines the business problem, audience and constraints before drafting implementation.
A human compares the options. AI can help expose questions and alternatives, but it does not approve the architecture.
AI drafts focused changes under direction. Work stays in reviewable units with clear conventions and a defined result.
A human reads the change, checks the assumptions and validates the affected behaviour and trust boundaries.
Measure relevant paths, inspect mobile layouts and check keyboard and reduced-motion behaviour.
Approve the release and prepare documentation, deployment access and an agreed support boundary.
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.
Bin Hashim Gadget
A headless storefront combining WooCommerce, Next.js and Cloudflare delivery.
- Next.js
- Cloudflare
Dr. Gummy
A subscription-focused WooCommerce store with tailored shopping functionality.
- Subscriptions
- PHP
Lafemeia
A custom WooCommerce skincare store with bespoke offers and bundles, using WooCommerce for inventory and checkout.
- Custom PHP
- CSS
- JavaScript
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.

