Jay Lawrence
Résumé
Let’s talk
All posts

AI-assisted development · Engineering workflow · Product judgment

How I use AI in my development workflow as a software engineer

A practical system for using AI to understand codebases, shape ambiguous work, implement carefully, and verify what ships—without outsourcing engineering judgment.

By Jay Lawrence Dimaano8 min read

AI is most useful to me when it makes the engineering process clearer. I use it to inspect more context, compare more options, and shorten the distance between an ambiguous problem and a verified solution—not to outsource judgment.

The operating loop

AI accelerates the work; verification determines what survives.

The useful output of each task is not only code. It is also better context for the next decision.

The operating principle

AI works inside my process, not above it.

The model does not attend the stakeholder conversation, own the production incident, or explain a tradeoff to the team. I do. That changes which work I accelerate and which decisions stay firmly human.

My goal is not to generate more code. It is to reduce the distance between an unclear problem and a verified solution.

Speed and accountability belong in different columns.

AI leverage

Inspect and draft

Move quickly through repository context and mechanical work.

  • Search
  • Compare
  • Scaffold
  • Refactor
  • Challenge
Human responsibility

Decide and own

Make product, architecture, security, and shipping decisions.

  • Understand
  • Choose
  • Review
  • Explain
  • Own outcomes
supports
AI can widen the search space; the engineer remains responsible for narrowing it correctly.

My workflow

Five loops move the work from context to confidence.

Every stage has a human gate and a concrete exit artifact.

  1. InputContext

    User outcome, constraints, nearby code, and existing patterns.

  2. DecisionPlan

    Facts, assumptions, risks, scope, and acceptance criteria.

  3. DraftBuild

    Mechanical implementation within known boundaries.

  4. EvidenceVerify

    Types, tests, build, browser journey, and diff review.

  5. SystemLearn

    Turn corrections into tests, tokens, docs, or rules.

Domain-heavy work—especially healthcare—stays bounded by product behavior, privacy, architecture, and evidence rather than model confidence.

Where it helps

The tool changes role across the development lifecycle.

Leverage is useful only when its corresponding check is explicit.

DecisionAI contributionHuman check
DiscoveryMap code, data flow, and nearby patternsIs the context complete and relevant?
Product shapingList states, edge cases, and acceptance criteriaDoes this match the real user decision?
ImplementationDraft components, tests, migrations, and docsDoes it respect system boundaries and craft?
DebuggingGenerate focused hypotheses from concrete signalsWhich hypothesis survives reproduction?
ReviewChallenge accessibility, performance, and scopeWhat does the actual diff and product prove?
The pattern is consistent: let AI increase breadth, then use product and engineering evidence to narrow the answer.

The boundaries

Some work should never be delegated blindly.

Credentials, private customer information, patient data, and confidential business material stop at an approval boundary. Generated code also does not get to establish an architectural pattern by accident.

I read what ships. AI can draft quickly, but responsibility cannot be delegated.

Three gates remain non-delegable.

  1. InputApproved context

    Sanitize and confirm the environment before sensitive material enters a tool.

  2. DesignDeliberate architecture

    New patterns require a reason, not merely generated precedent.

  3. ReleaseVerified ownership

    A responsible engineer understands, tests, reviews, and owns what ships.

The boundary is not anti-AI. It is what makes AI useful without turning convenience into authority.

A practical example

A feature should leave behind evidence, not only a diff.

Six artifacts turn an ambiguous workflow into reusable product knowledge.

  1. OutcomeUser statement

    Describe the result in the user’s language.

  2. ContextRepository map

    Find adjacent behavior, primitives, state, and tests.

  3. ScopeBounded plan

    Expose assumptions, edge cases, and stop conditions.

  4. ChangeDraft diff

    Delegate mechanics while shaping behavior directly.

  5. ProofVerified journey

    Exercise responsive, accessible, loading, empty, and error states.

  6. MemoryReusable rule

    Preserve the lesson as a test, token, component, or note.

The final correction moves out of the chat and into the codebase, so the next task begins with stronger context.

The result

AI gives me leverage when the feedback loop stays honest.

The value is not that AI can type faster. It is that I can inspect more context, compare more options, and verify more thoroughly—while remaining accountable for every decision. Used this way, AI does not replace the engineering workflow. It makes the workflow more deliberate.