cmChristian Mercado

Senior Software Engineer

Calamba, Philippines

A structured workflow for AI-assisted engineering.

I curate reusable skills and specialist AI assignments, adapted to repository code, documentation, and engineering standards. I own the scope, review plans and evidence, and authorize publication.

From scope to handoff

  1. Understand context and risk

    Read the request, repository standards, owning code, and affected callers. Identify data, permission, integration, and recovery risks before changing behavior.

    Output
    A bounded problem statement, source map, and risk notes.
    Human checkpoint
    I confirm the intended outcome and resolve material unknowns.
  2. Review the implementation spec

    Define expected behavior, edge and regression scenarios, affected files, exclusions, and the verification approach.

    Output
    A reviewed implementation spec with explicit completion criteria.
    Human checkpoint
    I review the spec before building. Material scope changes return for review.
  3. Implement within scope

    Use the repository’s existing patterns and dependencies, preserve unrelated work, and keep adjacent refactors outside the agreed change.

    Output
    A focused candidate diff that implements the reviewed behavior.
    Human checkpoint
    A larger solution needs a scope decision before implementation expands.
  4. Verify actual behavior

    Run the required repository checks and relevant safe API or browser checks. Exercise success, failure, and recovery paths against the actual caller when applicable.

    Output
    Results tied to the candidate and test target, with failures and gaps recorded.
    Human checkpoint
    Developer checks establish local readiness; they do not count as formal QA acceptance.
  5. Run four independent reviews

    Use separate, author-independent review assignments for behavior, coding standards, security, and UI/UX.

    Output
    A verdict and supporting evidence for each review perspective.
    Human checkpoint
    UI/UX approval requires rendered browser inspection, interaction, and responsive evidence.
  6. Fix and recheck

    Address valid findings, rerun affected checks, and return changed areas for review. Keep each result attached to the candidate it actually assessed.

    Output
    A revised candidate with reconciled findings and current evidence.
    Human checkpoint
    Blocking findings and unresolved required checks stay visible before I call work ready.
  7. Publish with authorization

    After explicit authorization, commit, push, and open or update the pull request. Review the published diff, remote revision, review comments, and CI results.

    Output
    A published candidate and a review of that exact revision.
    Human checkpoint
    I authorize publication. Publishing does not authorize merge or deployment.
  8. Plan QA and hand off

    Treat formal QA as a separate approved path. Review its plan before acceptance-test creation or execution, report each required scenario, and return product defects to development for a fix and retest.

    Output
    A scoped handoff with QA evidence or clearly identified unrun and blocked work.
    Human checkpoint
    I approve QA scope and execution. QA-only work does not implement product fixes.
Responsibilities and delivery gates

Four review perspectives

Each perspective has its own assignment and evidence. A self-check by the implementation author does not replace independent review.

Behavior
Check the agreed outcomes, affected callers, failure paths, and regression evidence.
Coding standards
Check repository conventions, maintainability, boundaries, and required checks.
Security
Check trust boundaries, permissions, sensitive data, and unintended external effects.
UI/UX
Inspect the rendered interface and exercise its interactions at relevant desktop and mobile widths. Source inspection alone cannot provide visual approval.

Who owns the work

These are responsibilities I assign to AI assistance, alongside my own role as the human owner. I retain ownership of scope and delivery decisions.

Human and AI responsibilities
RoleResponsibility
Human ownerI set the outcome, review scope and plans, authorize publication, and make the final engineering decisions.
Coordination assignmentAn AI assignment carries context, keeps scope and approvals visible, and reconciles findings and evidence for my decision.
Implementation assignmentAn AI assignment owns bounded code changes and developer checks against the reviewed spec.
Independent review assignmentsSeparate AI assignments assess behavior, coding standards, security, and UI/UX without approving their own implementation.
QA assignmentAn AI assignment derives coverage from the requirements and actual changes, then creates or runs acceptance tests only within the approved QA scope.

Readiness stays specific

Local readiness, publication, QA acceptance, merge, and deployment are distinct milestones. A passing local check does not prove a live integration or deployed behavior. I report the candidate, what was checked, and what remains unverified.

Development can end at a scoped handoff without entering formal QA. QA-only work follows its own reviewed plan and does not implement product fixes. Defects return to development, then come back for retesting. Merge and deployment follow the project’s own ownership and authorization rules.

I also curate evidence-backed lessons at handoff, distinguishing task-specific fixes from candidates for reuse. Updating persistent skills or guidance requires separate human review and approval.

How this portfolio was built.

This site is one working example of my AI-assisted engineering process: real source material, an agreed direction, implementation, and independent review.

1Research and define

The supplied résumé grounds the career facts. Mobbin provides real interface references; the audience and the work determine what belongs here.

Reference examples: Antimetal, Delphi. Their artifact-led and compact profile structures informed the exploration; the content is my own.

2Build and verify

Codex helps implement React, TypeScript, and CSS Modules. Type checks, a static production build, and Playwright journeys check the result against the agreed behavior.

3Review and decide

Separate review passes examine behavior, code standards, security, and UI/UX. Impeccable supports critique and audit; Emil and Animate guide interaction details. I choose the direction and make the final engineering decisions.

Selected local tools

Engineering workflow dashboard

Python · JavaScript

I built a local dashboard to track AI-assisted tasks, review findings, and delivery evidence across projects.

An explicit report registry uses revision checks, file locking, and atomic writes to prevent conflicting updates. Automatic refresh preserves the selected task and open evidence.

AI usage reporting

Python · HTML · CSS · JavaScript

I built weekly and monthly Codex usage reports covering tokens, cache accounting, and API-equivalent cost estimates.

The reporting handles duplicate and inherited records, missing data, and reporting boundaries. It processes usage metadata without exporting conversation message bodies.

Codex prepares the work. I own the engineering decisions.

It does not approve a plan, merge code, or release a change.