Mark Bennett on Using Claude Code for Application Development - SKMurphy, Inc.

A conversation with Mark Bennett, an experienced software developer, about his experiences using Claude Code for application development.

I first met Mark Bennett in 1998 when I was working at MMC Networks as the Director of Product and Customer Support, and he was VP of Engineering at New Idea Engineering. One challenge I faced at MMC was making it easier for team members to share knowledge. When I had worked at Cisco in the early 90s, the customer support team had leveraged the Verity intranet search engine to curate the technical documentation and all of the emails with questions from customers and the answers support had supplied. Overnight answers improved because it was much easier to find relevant and up-to-date information. I wanted the same thing for my team. Mark was able to oblige, and I have stayed in touch ever since. Recently, he has shared his experiences working with Claude Code, and I thought it would make for an interesting Q&A. We had an extended conversation and then refined the transcript into this blog post.

SideBar: What is Claude Code?

Before we dive in, let’s do a very quick review. CC is a command-line tool that helps you with your software project. You give it selected permissions for things like editing and compiling code, and it shows you what it’s doing as you proceed. You’re free to step through every single diff if you like, though you may get over this pretty quick. You might start to trust it more over time if it seems like it knows what it’s doing a majority of the time. It works from the command line, where you type commands, vs. a modern graphical UI app; it’s a very retro vibe, though it’s only been around since early this year.

Claude Code, the Hype is Legit

Sean: Mark, you bring more than two decades of experience to designing and developing software applications. There is a fair amount of hype around Claude Code. What has been your experience working with Claude Code?

Mark: In my experience, the hype is legit.

The most striking shift is time compression. Work that used to stretch across a full year can sometimes be condensed into a long weekend. That’s a massive boost, and even if you don’t believe the “two orders of magnitude” claim, your mileage may vary depending on the project and your own baseline coding speed. If you’re already a fast coder, the multiplier might be smaller, so maybe it’s only a factor of 10 – that’s still enough to move things along. Of course, the current model’s latency slows things down; I assume this will improve substantially over time. If Claude’s prompt latency went away, then it’d be even faster.

It’s the closest thing I’ve seen to a “software singularity,” or maybe another version of “The Lathe of Heaven” (1980), where your dreams literally start becoming reality. Another way to put it: if you’re stuck with mission-critical software that’s essential but… let’s be honest… totally sucks, you can finally think about actually rolling your own. And you can take the time to make the right architectural choices instead of the most expedient. It reminds me of the shift TiVo brought to television: suddenly you weren’t forced to accept the medium’s limitations. You could shape it.

And sometimes the best advice really is: “Just try it.” Spin up a safe branch in Git, explore a redesign, test an idea. My friend Scarlet eventually said something similar to me after I asked her roughly a thousand Photoshop questions—at some point, you have to just try it! Claude Code makes that feasible.

Now, is it more fun than gaming? I think so. But certainly no disrespect to the ROG crowd; actually, I think many of them would find it very engaging. And as it is with gaming, the time disappears the same way: four hours gone before you know it.

And a quick salute to the command-line warriors out there: CC is all about the command line.

Iterations!

Sean: Is there a central theme or strategy you’d call out for this new development lifestyle?

Mark: Iterations! Think in terms of taking baby steps—but HUNDREDS of them. Instead of long planning cycles, you move in a rapid loop of try ? evaluate ? refine. It’s shockingly fluid. This might be starting to sound a little like “Agile”, but your “sprints” take a day at most, maybe an hour, not two weeks.

Pairing Claude Code with git is like those old peanut butter-and-chocolate commercials: a really great combo. Branches become your playground and your guard rails. Spin one up, try an idea, merge it, toss it, or stash it for later—no ceremony required.

One of the best side effects is that you can stop writing Jira tickets. Honestly, it’s often faster to fix a bug than to write the actual Jira ticket describing it. I keep a lightweight, single-line-per-item TODO list, “vi” anyone? Some project managers are really addicted to Jira as a planning tool, and I get that, so I suppose Claude could create the tickets.

This speed even makes re-architecting less intimidating. You can reshuffle a design in under a day. Heavy use of Git helps anchor the process: capture every experiment, branch freely, and keep the history clean.

And Claude itself is a Git Ninja. It handles all that advanced stuff effortlessly—rebases, squashes, selective commits, branch cleanups. You can literally tell it, “commit and push,” or “make this change across all branches,” and it gets it right. It feels like having a senior engineer who’s always available and never gets tired of bookkeeping.

The result is a development workflow that rewards curiosity and reduces friction. You iterate more, fear less, and the codebase actually gets better because of it.

Ideal for Technical Project Manager, and Great QA Folks

Sean: OK, so developers love it, but who else might be a good fit for Claude Code?

Mark: Interestingly, I can see two other groups shining especially bright in this brave new world: Technical Project Managers and great QA people. These folks are naturally articulate, detail-oriented, and comfortable translating fuzzy requirements into concrete steps. Claude Code amplifies that skill set dramatically.

Of course, engineers should be doing their QA as well. Unit tests aren’t going to save the day; actually using the system end-to-end will spot problems quickly. Touch it. Break it. Explore it the way a real user would. People who test like that become incredibly effective because Claude handles the mechanical parts while the human handles judgment, intuition, and product sense. QA folks with good UI testing experience will have a target-rich zone.

There’s also a fascinating angle for outsourcing and remote teams. I fully expect some individuals to become true experts in AI-assisted development. And it’s already faster than “regular” Claude was back in August last year when I started using it, even if the comparison isn’t perfectly apples-to-apples.

By the way, I still sometimes use classic Claude UI in the web browser. Sometimes if CC is down, regular old Claude is still up. And you can paste a fair amount of source code into a Claude chat, I think it might do a more thorough job on isolated files. You do a lot of manual copy and pasting that way. Hint: If browser Claude hangs, just temporarily turn off your WiFi and then back on again; that’ll unhang it.

Downsides

Sean: So you have experienced some clear benefits with Claude Code. What are some of the drawbacks or downsides?

Mark: Before I say anything, I should mention that I only produce a list of things this long for things I really care about. If I didn’t think Claude Code was so transformative and awesome, I wouldn’t bother cataloging its flaws with this much passion. The criticisms come from wanting it to be even better, not from wanting to dismiss it. Also, this is December of 2025, so if reading this a while later, things might have changed, hopefully for the better. With that said, yes, there are certainly downsides:

It sometimes does surprisingly silly things and seems to lack common sense and guardrails at other times.

Claude can get extremely complex logic right, and then immediately trip over something that to us seems like plain old common knowledge.

Claude will sometimes remove things. Remember, I suggested using Git! Sometimes I picture Urkel saying, “Did I do that!?”

Claude can understand a complex multi-module architecture… and then happily suggest removing the one feature that the entire project exists for. If your software does X, but that’s not going well, CC might suggest removing X. You have to remind it that X is the main point of the code! Another example, file dialogs need a browse button, everybody knows that, but I have to always remind Claude.

This mismatch—brilliance paired with a lack of common sense—happens more often than you might expect.

Prompt-to-prompt waiting fatigue: You spend a lot of time waiting for Claude to do its thing. This is perhaps ironic since I just said that it compresses months into days—but the constant delays add up.

Fragile startup/settings behavior. Which files Claude reads and when, and why one over another specific startup file, this type of confusion. The startup settings you take the time to create are often seemingly ignored, plain and simple. I really wish I knew how CC works internally.

Unprompted Git commits (This is the worst surprise.) Claude Code sometimes commits to Git without being asked. And even worse: it may commit before the change is tested; I don’t like checking in obviously broken code.

I’ve told it repeatedly not to do these commits. I’ve put this in Claude’s settings files and project files and reminded it interactively. Even with that guidance, after a time, it starts with that nonsense all over again. It apologizes after the fact, but it still does it.

Also, it loves adding a three-line “Co-authored by Claude…” message to your commits, unless you catch it. I don’t mind it adding one line, but three is two too many.

The dreaded “Compacting conversation…” This can feel like a TV commercial, over and over and over again.

When a session ages, “compacting” starts happening more often, sometimes every couple of minutes. The workaround: manually save context, then reopen Claude; but this often loses some of the context. Automatic Compacting trims context; the model only keeps “highlights” and more recent tasks and context, not the full conversation. I assume it’s doing something very important. I’d prefer that it were faster and not as often.

An easy fix, when it’s getting close to compacting time and I’m not typing or scrolling in CC, kick off the compaction then. It might be done before I even notice. Currently, you’re away doing something for a while, then just start to type, and THEN it decides it needs to Compact, it’s like “why didn’t you do that when I wasn’t here!?” Again, this seems like a really easy fix.

Occasional forgetfulness and instruction drift. Sometimes it forgets what you said. Other times, it misinterprets a “no” statement as a “yes”.

Documentation-obsessed mode. Documentation is great to have, but Claude Code can fixate on polishing docs to the Nth degree when you just want to get back to the code. This is configurable, but still wastes time until tuned, and works inconsistently.

I wish I could easily point to things: screenshots, UI glitches, layout issues, or share a whiteboard with Claude. Currently, all of these must be described completely in text. Often twice. Sometimes three times. I’ve tried uploading a marked-up screenshot, but with mixed success. A markup tool would be enormously helpful. or share a whiteboard with Claude.

Endless and often false “it’s fixed!” proclamations. It does compile things to check baseline correctness—but not consistently. And sometimes the model can output dozens of pages in one go, zooming past.

Verbosity and the weird metaphors. Claude uses an orange or red word near the bottom left of the screen to show that it’s working, but it’s often some weird verb. “Discombobulating… Levitating… Zigzagging…” It once said “Embellishing…”, and I’m like I wouldn’t want it saying that if I didn’t realize it was just random gibberish. In addition to being silly (when you’re often not in the mood), they occasionally sound like real progress updates like “Inferring…” or “Architecting…”, but are still usually totally random verbs.

What can be more confusing is that it sometimes tells you exactly what it’s doing, putting the information in that same location using the same font. So you can’t just get used to ignoring the orange/red text. This is a small thing, but Anthropic needs to sort it out. It seems pretty easy: just don’t do that.

We need a larger context window. In regular Claude, the current 200k is being upgraded, in beta test now, at the 1M mark! But I think Claude Code’s limits are much lower–and I pay for the $200/month version. I see errors like Error: File content (27931 tokens) exceeds maximum allowed tokens (25000); 25,000 is pretty small when dealing with entire source code files. Come on, Anthropic, at least give us 200,000 tokens. I wonder if this partially explains the forgetfulness.

Repeating certain bugs over and over. For example, with Java object persistence, I have to remind Claude to do that whenever I add an item to the UI; it should get this by now. This is similar to item 5, “Compacting Conservation.” Getting object data saved to disk can sometimes take 5 rounds of corrections.

CC can occasionally create “spaghetti code.” For example, repeating the same code multiple times in various places, instead of using the base class, or not refactoring into a shared method, or putting a TON of stuff into one giant Java file.

It defaults way too often to the Java instanceof operator, a sure sign of a junior coder. Claude skips obvious refactors unless prompted. Another example, how many times have I told it not to hard code color values inline, that they should be constants at the top of the file; I have to remind it every single time. Conversation persistence is a real architectural issue with CC at the moment.

It has some input issues. Sometimes it won’t let you type; sometimes it buffers; sometimes keystrokes seem to vanish.

It must be popular, because I get overload and service errors. You’ll see things like: API Error: 500 {“type”:”error”,”error”:{“type”:”api_error”,”message”:”Internal server error”}}, or messages effectively saying they’re overloaded (a good problem to have for a business, too many customers) Again, I’m sure Anthropic is aware of this and working on it.

I’d like it if it would do interactive code reviews with me, one step at a time. But it doesn’t seem to understand that.

Other Positives

Sean: As we get close to the end of our interview, are there any other small but meaningful positives you’ve found when working with Claude Code?

Mark: My enthusiasm comes from the confidence I have gained working with Claude. Here are the things I genuinely enjoy:

It handles typos gracefully. Even messy input, fat-fingered text, or jumbled notes often get interpreted correctly.
You can be inconsistent in how you refer to things, and it still follows. Names, abbreviations, and shorthand–Claude usually does the mental mapping for you. You can even start something and it will often fill in the rest.
Claude is polite. I still say “please” and “thank you”—and occasionally I shout in CAPS, but CC is always positive. It’s a good habit, even if Claude doesn’t need the courtesy.
It can usually undo what it did, so at least the recovery is solid. This is a shorter-term “undo” than switching out of a Git branch.
It never complains or whines.
It handles busy work cheerfully.
It enjoys producing documentation.
No request is too small, too trivial, or too repetitive. For UI work, I frequently have it adjust things by single pixels – it never accuses me of being a “micromanager.”

These small things accumulate. They make the tool feel more like a partner than a utility—one that helps you keep momentum and stay optimistic about whatever you’re building.

In Closing

Sean: This has been a great conversation based on your direct experience over the last two years. Any closing thoughts?

Mark: We’re entering an era that feels less like a traditional hackathon (hackathon 2.0? AI-style?) and more like “swarm vibing”—one coder at the keyboard with CC, a few collaborators tossing in ideas, and a moderator keeping track of the to-dos while the model handles any programming language you throw at it.

Claude Code is astonishing—but imperfect. These rough edges matter because the tool itself is powerful enough that you genuinely want to build big things with it. So the critique is really a form of respect: the stakes are high, and the potential is enormous.

I certainly find myself saying “we” when I refer to my solo coding excursions with Claude, I think that says something about CC. I don’t say that about compilers.

Bottom line: Claude Code can genuinely shift what’s possible, in a surprisingly short amount of time. It can amplify the productivity of an individual developer tremendously. The excitement isn’t just hype—there’s something real here.

Mark Bennett: Resources For Claude Code

Mark Bennett’s Python OpenCV Pipeline: https://github.com/ttennebkram/webcam-filters

Mark Bennett’s Java OpenCV Pipeline: https://github.com/ttennebkram/opencv-pipeline

Very interesting article about maintaining state with CC: https://www.humanlayer.dev/blog/writing-a-good-claude-md

About Mark Bennett

Mark Bennett is the cofounder and CTO at New Idea Engineering, Inc., a software consultancy. Mr. Bennett also cofounded and served as CTO of Searchbutton, Inc., an early hosted search company. Mr. Bennett has also held positions at Lucidworks, Inc., Verity, Inc., Access Technology, Inc. and the Portsmouth Naval Shipyard. Mr. Bennett attended Worcester Polytechnic Institute, University of New Hampshire and Northeastern University.

About Sean Murphy

Sean Murphy is a co-founder of SKMurphy, Inc., a small consulting firm that supports teams of engineers and scientists who are bootstrapping a startup to generate leads and close deals. He helps founders find early customers and early revenue. Prior to founding SKMurphy,Inc. in 2003, Mr. Murphy has worked in a variety of roles for more than two decades: software engineer, engineering manager, project manager, business development, product marketing, and customer support. Companies he has worked directly for include Cisco Systems, 3Com, AMD, MMC Networks, and VLSI Technology. He has a BS in Mathematical Sciences and an MS in Engineering-Economic Systems (now MS&E) from Stanford.