More Code with Jason episodes

329 - Adam Dawkins, CTO of Dragon Drop, Returns thumbnail

329 - Adam Dawkins, CTO of Dragon Drop, Returns

Published 2 Nov 2026

Duration: 01:00:17

The podcast explores how AI is changing software development, emphasizing problem-solving over coding and the importance of iterative design and TDD.

Episode Description

In this episode I talk with Adam Dawkins about the paradigm shift in development with AI, how expectations have changed, and the essential principles...

Overview

Adam Dawkins, CTO at Drag and Drop, discusses how AI tools are reshaping expectations for software agencies and freelance developers. Some clients now spin up quick solutions using tools like Lovable, prompting a strategic question: should agencies facilitate that self-service approach with better APIs, or compete on speed? Central to the conversation is the company motto that "it's not about the code" - the real goal is solving problems, sometimes by simplifying a policy rather than building an algorithm. Dawkins emphasizes that a pull request merged is not a deliverable; only live, useful software counts. He also challenges the common analogy to the printing press, noting that unlike literacy, programming carries real risk of self-harm when non-experts build systems without understanding relational theory or security.

What If

  • What if you offered clients a better API instead of competing on speed with their lovable apps?

    • Move: Propose an MCP or improved read-only API layer on your existing platform so clients can spin up their own quick views, while you protect the write-only logic in the main app.
    • Why Now?: Clients are already building single-purpose lovable apps that read from a copy of the database, and the question is whether your job is to facilitate that or compete on speed.
    • Expected Upside: A possibility is that you shift from gatekeeping to enabling, preserving trust while the main app's write paths stay under your control.
  • What if you stayed on pen and paper until you could not learn anything else before writing a line of code?

    • Move: For your next engagement, open a blank sheet or Vim and draw arrows between entities before any UI mockup or scaffolded code; only escalate fidelity when the paper can teach you no more.
    • Why Now?: The AI-generated output that looks polished immediately creates an uncanny valley where visual polish masks unverified logic, and a high-fidelity mockup tricks stakeholders into thinking the hard part is done.
    • Expected Upside: A proposal is that you catch wrong-problem waste at the cheapest fidelity level, where a big Sharpie cross-through costs nothing and there is no UI to fool you into feeling productive.
  • What if you used AI only for the part you did not know and hand-wrote the crux of the problem?

    • Move: When facing an unfamiliar algorithm or pattern, ask the agent to identify and prototype it, verify it against a brute-force or reference implementation, then build the domain-specific glue (matrix construction, business rules) yourself.
    • Why Now?: In the Hungarian-algorithm example, the agent surfaced the right known solution and a two-line brute-force check, but the deterministic, domain-specific matrix from appointments and reps was the real problem and was built manually.
    • Expected Upside: A possibility is that you capture AI speed on solved-problem lookup while retaining the developer judgment needed to ensure deterministic, correct results on the part that actually matters.

Takeaway

  • Start every feature on pen and paper before writing code. "let's try and let's stay on pen and paper until we can't learn anything else from pen and paper. Then we move up to the next level of fidelity". Iterate at the cheapest level: "I can afford more paper, right? So I just throw it away, use another sheet".

  • Solve problems without code when a policy change suffices. "what if you just gave everyone 15 days a year and it was simple?". This builds client trust as a fiduciary relationship and frees capacity for problems that genuinely need code.

  • Use AI agents for unknowns; write known solutions yourself. "it's easier to use it for something I don't know how to do". For the Hungarian algorithm example, Claude identified the problem type, but the developer built the matrix-producing logic manually because "that was the crux of the problem".

  • Commit after every micro-step during agentic coding. "I actually get Claude to commit a lot because then I've just got all of these tiny stage gates of decisions". Frequent commits prevent the mega-diff that leaves no reset point.

  • Keep client-facing artifacts low-fidelity to maintain problem focus. "sometimes I'll even open Vim occasionally on a client call and just type with arrows". High-fidelity mockups cause clients to assume "the hard part's already done", shifting attention to colors and borders instead of the core problem.

Recent Episodes of Code with Jason

5 Sept 2026 327 - Will Carey, CTO of Brand New Box

"Explores how software agencies are shifting from coding to defining client needs, emphasizing AI's role in development while stressing the importance of conceptual design and real-world problem-solving."

More Code with Jason episodes