Your client used to pay by the hour without asking. Now they open the conversation with a line that's become common: «Why am I paying you for 40 hours when you generated this with AI in ten minutes?». It isn't necessarily hostile, but it's real, and ignoring it costs you the contract.

The problem is that client trust rested on a silent assumption: the hours you billed equaled human effort. AI agents shattered that. You now have to prove what used to be obvious, and proving human authorship of code has become a negotiating point, not a technical luxury.

Why the question flipped so fast

Two years ago your client assumed you wrote every line by hand. The only variable was your speed. Today the client — because they use ChatGPT themselves — knows that a 200-line block can appear from a single prompt. So why pay by the hour?

This creates a new trust gap. It isn't about code quality; it's about provenance. The client doesn't doubt the app works — they doubt the invoice reflects real human work. And right now you have nothing to answer with but your word, and your word is no longer enough.

What actually shows up in the work pattern

Code from three sources leaves completely different traces in the editor, and those traces are measurable:

  • Character-by-character typing: irregular keystroke rhythm, thinking pauses, backspaces and corrections, lines that grow gradually. The cadence is inherently human — nobody types a whole function at a constant, uninterrupted speed.
  • Pasted input: a block appears at once, but its size and origin distinguish it. Pasting two lines from Stack Overflow is one thing; pasting an entire file is another.
  • Agent-generated code: large blocks that appear with no preceding keystrokes, at an input speed no human reaches, often with strikingly uniform formatting. No pauses, no hesitation, no gradual correction.

The difference isn't in the code's «quality» but in its temporal signature. Keystroke patterns, input speed, and block size tell a story the final code alone cannot. That's exactly what the «human signal» in TaskTrace measures: it separates what you typed by hand from what flowed in from somewhere else.

The honest other side: using AI is not a flaw

Let's be direct. The problem isn't that you use AI. A developer who uses Copilot and ships in half the time delivers more value, not less. The problem is ambiguity, not the tool.

When you hide that you generated a chunk and bill it as hand-written, you're betting the client won't find out. When they do — and they will — trust collapses entirely, even for the parts you genuinely wrote yourself.

The developer who says «I generated this module with AI, then reviewed it, fixed three bugs, and wrote its tests by hand» negotiates from a far stronger position than the one who claims he wrote every character himself.

Transparency flips the equation. Instead of defending yourself, you present a clear process: here's what I generated, here's what I reviewed, here's what I fixed and now guarantee. The client isn't buying lines — they're buying accountability that the code works and that you own it.

How to prove authorship without sounding defensive

Don't wait to be asked. Build the proof into how you work:

  1. Separate generated time from human time in your report. Instead of «40 hours», offer: 12 hours hand-written, 6 hours reviewing and fixing AI output, 4 hours testing. The same number becomes persuasive once you break it down.
  2. Use a tool that tracks provenance automatically. Manual tracking is contestable. Editor-linked tracking — keystrokes, speed, block size — gives evidence that doesn't rest on your word alone. That's what the TaskTrace VS Code extension does.
  3. Document review decisions, not just output. «I rejected the agent's error-handling suggestion because it didn't cover the offline-network case» — that sentence shows you're the engineer, not the operator.

How to price AI-assisted work

Here's the core. If you keep pricing by the hour or by line count, you're competing with a tool that generates a thousand lines for free in a minute. You'll always lose.

Price by value and by accountability. The questions that set your rate aren't «how many lines did you write?» but:

  • Do you guarantee this code runs in production?
  • Do you own responsibility for security holes and edge cases?
  • Do you know why this solution was chosen, and can you modify it six months from now?

AI generates code, but it doesn't carry responsibility, doesn't understand the client's project context, and doesn't stand in front of them when the system falls over. You do. That's your value, and it doesn't drop because you use a tool that speeds up the mechanical part.

Practically: move toward outcome-based or project-based pricing, backed by transparent time data showing where your real effort went. See how TaskTrace ties verified time to the invoice on the features page, and read more on pricing in the blog.

The takeaway you can use tomorrow

The client who asks «why pay by the hour?» isn't attacking you — they're asking for a new model of trust. Whoever offers that model first — clear proof of what's human, honesty about what AI generated, and pricing by value — wins the contract. Whoever clings to the old ambiguity loses it to someone more transparent.