Blog · From the team

A Day in the Life of an Engineer in the AI Era

By Stephanie Hernandez, Forward-Deployed Engineer · October 21, 2026

Typing was never really the bottleneck, but it used to fill the day. Now AI coding agents do most of the typing, and what's left is still deciding what to build, saying it precisely, checking that what came back is actually right, and steering the system so tomorrow's output is better than today's.

Here is what that looks like across an ordinary day. But first, what the day used to look like.

Before: the day I used to have

Not long ago, a feature could take me most of a week, and most of that week went to writing code, tests, documentation.

The morning started with standup, then a slow climb back into yesterday's code. Before I could change anything, I had to find where the change belonged. This meant reading through modules, tracing call paths, searching for the function someone renamed last quarter, running into existing bugs, etc. Then came the inner loop, write a few lines, run the tests, read the stack trace, search the docs or somewhere for the error, and try again. Tests and documentation came last.

Review was a queue. I'd open a pull request and wait for a couple of hours and sometimes for over a day for teammates to review it, while they waited on me to review theirs. Many of the comments were about naming, syntax, formatting and missed edge cases. By the time a feature got merged, I'd switched context several times already.

The bottleneck was my own hands and my own attention, one engineer, one task, one branch at a time.

Morning: writing the spec, not the code

Now, my longest focus block of the day now goes to writing plain English. I write the issue the way I'd explain it to a colleague:

  • The problem in one sentence, with the failure a user actually hit.
  • Acceptance criteria that a test can check.
  • The constraints that might not be obvious from the code: what must not change, which past decision this must respect.
  • What "done" looks like, including the failure mode, e.g. a missing file must produce a visible error, not a quiet fallback that looks like success.

The acceptance criteria has become the real source code. A vague spec can cost hours of review later, while a precise one costs a little time now as it leaves less room for model assumptions or ambiguity.

Late morning: fan out

A feature breaks into multiple stories. Each one goes to its own agent, in its own isolated worktree, so they can't trip over or override each other. One agent writes the backend implementation, one the tests, one the docs, one does a security pass, etc.

While they run, my job looks a lot like a dispatcher's:

  1. Answer the questions they raise.
  2. Notice when two of them are about to make conflicting assumptions, and settle it once for both.
  3. Resist the urge to jump in and type. If I fix it by hand, the agent learns nothing and the spec stays wrong.

Parallelism is the big win here, multiple concurrent stories in the time one used to take. The less obvious cost is that I now hold multiple streams of context in my head instead of one.

Afternoon: review is the job now

This is where most of my day goes now, and it's the part I've had to re-learn.

Reviewing agent-written code isn't like reviewing a colleague's. The syntax is almost always clean. The names are reasonable. The tests pass.

So I've stopped reading top to bottom and started asking questions instead:

  • Does it do what the acceptance criteria say, or what they sound like?
  • What happens on the unhappy path? Agents write the happy path first and the error path last, if at all.
  • Did it change anything I didn't ask for? A one-line fix that also "tidied" three other files is a red flag.
  • Are the tests testing behavior, or testing the implementation it just wrote? A test that mocks the exact thing under test proves nothing.

Late afternoon: steering

Every correction I make today is wasted if I have to make it again tomorrow. So part of the new process is turning corrections into durable instructions.

Here's a recent one. I noticed our test coverage had slipped below our target percentage. No single change caused it. The agents were writing tests with every feature, just not quite enough of them, and nobody had told them to check. A slow drift like that is easy to miss when no one is writing the tests by hand.

So we updated our tester agent. It now checks coverage on every change and flags anything that falls below the target, so the gap shows up in review instead of piling up quietly.

This is the closest thing to programming I still do every day. I'm not writing the code. I'm writing the environment the code gets written in. One good sentence in an instruction file can pay off across many future runs.

What changed, and what didn't

The job didn't get easier. It just shifted. Most of the hours that used to go to producing code now go to specifying it, verifying it, and shaping the system that produces it. Along with this comes how productivity gets measured. It can no longer be measured in the amount of code lines or number of tickets closed. Instead, it should be measured in how often the right thing ships and how likely it is for the same mistake to happen twice.

Then and now

ThenNow
Write the codeWrite the spec the code is checked against
Debug my own mistakesDebug plausible answers I didn't write
Review a teammate's PR now and thenReview all or most of the day
Hold one task in my headDispatch and track several agents at once
Fix it and move onFix it, then teach the system so it stays fixed

What didn't change is that someone still has to know what "right" means, notice when the green checkmark is lying, and own the decision to ship.

End of Day Outcome

Before, a single feature could take a whole week at a minimum. Part of that was the time it took to implement and test each story. The other part was waiting on engineers with other specialties, such as DevOps and QA, and fitting into their schedules. Now, with the help of our SDLC personas, an entire feature can be done in a day. We used to be a full-stack team. Now, every engineer in our team carries a full-stack team of their own.

Here's today's outcome:

  • One feature completed end to end
  • Three open tech-debt issues addressed on our release workflow
  • A larger feature started. Most stories are already implemented. A few remaining stories are blocked on a story in a separate feature. What's left for me is the part that matters the most, taking the time to review, run tests, and verify it does what it's expected to do.

— Stephanie