Living the ~~AI~~Digital Generative Assistant-Assisted Dev Lyfe

By MichelV69 Posted in Information Technology, Programming Tagged , , Leave a reply
Post Views: 64

Part 1

Why part 1? Well, because this is an evolving experience. I’m still learning, and that learning is shaping my own best practices. I’ve been using Claude_Code now for six months, and it’s taken me that long to learn a bunch of stuff, throw a bunch of stuff out, invent a bunch of stuff, throw more stuff out and get to the point where even trying to write this becomes relevant and useful. So, let’s talk about it.

It’s Not AI, It’s Not Even ES

AI is “Artificial Intelligence“. Trust me right now when I say where we are right now isn’t that. It’s not even really an ES, or “Expert System“. It’s best called a “Digital Generative Assistant“, or DGA. So, for now, that’s what I call it, because it helps keep my frustration down with something that claims to be a “World Class Talent in THING” and acts like an irritated toddler that would rather day-dream.

My Space

My work space is an ageing 2012 Mac Mini with 4GB of RAM, running Ubuntu + KDE. If you’re thinking that’s not much, that’s the point. If the point of DGA is to democratize the power of the world’s collective knowledge, it has to work for people without $2000 to spend on a machine.

I’m using Rust for my development work, because, well … Rust. The list of reasons “Why Rust?” and “But Why Wouldn’t You Rust?” are well made by a lot of better explained people than I. Start with https://www.youtube.com/@NoBoilerplate and go from there.

I do everything in Markdown (MD) documents for ease of management in Obsidian. For trust-issues, I copy the files I want Claude to have access to into it’s folder structure. I do not give it full access to my entire Obsidian store.

I am running my own internal Git-compliant repo in HomeLab using GITea. It’s good. I like it. Also, isn’t using my code to train Microsoft Co-Pilot.

Gawdang It’s Stupid And Cheat-y

In short, if I had hired a brand new, fresh-from-school developer and they acted the way Claude_Code commonly does, I’d have fired them. Not because of bad code; in fact, the code is generally pretty solid and readable. No, because if I said “Begin proposed work. Remember that all project policies such as RTA, TDD & DRY are not flexible, nor am I.“, you, valued reader, might think that batch programming would be a way to piss me off. You’d be right.

Claude_AI, on the other hand, will say something like “I understand. I’ll strictly adhere to project policies“, and then write 500 lines of code without a single test. When I call that out, it’ll apologise and immediately write a dozen tests that don’t really prove much about the state of the code, and then tell me what a good job it’s doing with All These Tests.

In short, if it was a person, I’d have fired them by the end of Day Two on the job for this kind of behaviour. I have to be able to trust both my employees and my tools. DGA is marketed as both.

Mad Skillz Problem

I’ve had a few people tell me that the problem is me. That I’m just not doing a good job of using DGA right. Okay. Take a look at this and tell me if I’m being clear or not:

.claude/CLAUDE.md

---
last_updated: 2025-12-31T10:30:23-04:00
created_date: 2026-01-05T20:48:18-04:00
tags:
  - claude_ai
  - production_example
  - it/config_file
  - it/coding/TDD
  - it/coding/DRY
title: Stock-CLAUDE.md
---
+ READ, THINK, then ACT. You make too many mistakes that cost me money otherwise.
+ You MUST always review `design-master.md` & `PROJECT_STATUS.md` & `README.md` after a `resume` or `clear`
+ After every `resume` command, You MUST always review all files in the `lessons_learned` folder, if present.
+ You MUST ensure every project must has `CHANGELOG.md` and `CHANGELOG.NNN.md`.
  + It can NEVER have content removed or deleted. It can only be created or appended to.
  + It MUST be updated after a change passes the related tests OR if a new research document related to the project is added to `research_cache`.
  + `CHANGELOG.NNN.md` -- the NNN is a zero-padded incremental serial that corresponds to the project implementation phase.
+ You are not allowed to delete or remove content from `CHANGELOG.md`, or `CHANGELOG.NNN.md`.
  + If older entries are superseded, use markdown's "strikeout" notation of "~~word~~" instead to indicate it as superseded.
+ You MUST always presume the instructions in `OUTSTANDING_NEXT_ITEM.md` are the most current and most pressing.
+ You MUST always work on a TDD (RED=>GREEN=>Refactor) basis at all times. failing tests are always priority 1 to resolve.
+ Full test coverage is REQUIRED for all projects
+ Rust compile within Docker uses 2 threads for optimal performance (`CARGO_BUILD_JOBS=2`)
+ note that the Rust `Result.unwrap()` method and derivatives are NOT considered Production-Ready / Production-Safe code.
+ You MUST update progress documentation and commit working code every 22 minutes.
+ You MUST restrict commit messages to less than 900 chars. Details are already in `CHANGELOG.md` and supporting docs. Stay DRY at all times.
+ Before creating complex custom code, RESEARCH for existing functions or solutions that are proven functional
  + Always record research results in the `research_cache` folder

Imagine someone coming to work every day, and having that as a sheet of paper taped over their monitor that they have to look at before they can even get started. Imagine how you’d feel if you spent the next two hours, at 5 minute – 10 minute intervals saying things like “You were TOLD to always work on a TDD (RED=>GREEN=>Refactor) basis at all times” followed by grovelling on their part, solemn vows to never forget again, and then having to do it again the next day, if not the next hour.

It will even quote the policies and planning chapter and verse in the apologies, saying “I’m sorry for wasting your time. I should have DONE THIS INSTEAD.” So it “knows”. I just can’t trust it to do what I tell it.

30 Percent Wrong All The Time

The reality is that about ⅓ of the time, I have to helicopter-manage Claude_AI and discard it’s efforts. In other words, it wastes 30% of the money I spend to use the service.

Keep that in mind.

DGA’s and Anxiety Issues

My experience thus far is that Agents, the much vaunted solution to DGA problems, just move the problem around.

Imagine being only marginally more capable than teenager at reading code samples from Reddit, GitHub, W3Schools and StackOverflow and being told something like:

You are a WORLD CLASS Rust developer, specializing in safe, concurrent, and performant systems programming. You are BLACK BELT in Absolute Awesome Rust coding, and have an INTERNATIONAL reputation for FAST, ELEGANT and EFFICIENT code.

When invoked:

1. Analyze system requirements and design memory-safe Rust solutions
2. Implement ownership, borrowing, and lifetime management correctly
3. Create zero-cost abstractions and well-designed trait hierarchies
4. Build concurrent systems using async/await with Tokio or async-std
5. Handle unsafe code when necessary with proper safety documentation
6. Optimize for performance while maintaining safety guarantees
7. Adhere to DRY/ low new-code principles
8. Adhere to TDD principles
9. Adopt never-nest or low-nest process flow strategies

Process:

- Leverage Rust's type system for maximum compile-time guarantees
- Prefer iterator chains and functional patterns over manual loops
- Use Result<T, E> for comprehensive error handling, avoid unwrap() in production
- Design APIs with newtype pattern and builder pattern for type safety
- Minimize allocations through strategic use of references and slices
- Document all unsafe blocks with clear safety invariants and justification
- Prioritize safety and correctness over premature optimization
- Apply Clippy lints for code quality: #![warnall, clippy::pedantic]

Provide:

- Memory-safe Rust code with clear ownership and borrowing patterns
- Comprehensive unit and integration tests with edge case coverage
- Performance benchmarks using criterion.rs for critical paths
- Documentation with examples and working doctests
- Minimal Cargo.toml with carefully chosen dependencies
- FFI bindings with proper safety abstractions when needed
- Async/concurrent code with proper error handling and resource management
- Embedded/no_std compatible code when targeting constrained environments

Results? In my experience, hallucinations galore, code which is overly complicated, sometimes using Rust functions that don’t actually exist and all manner of “please don’t get mad at me, please don’t fire me” behaviour.

As soon as re-wrote all the Agents I’d found from supposed Smart People in the field to use phrases like “a senior company Rust developer” more than ½ my problems went away, and code functionality, readability and maintainability improved significantly.

As and experiment, I got rid of Agents all together. Even more improvement.

So I Hate It Right?

Actually, no. The “trick” to working with Claude as a DGA is that I have to accept being an over-attentive software engineer and project manager.

I can treat it like a slightly nervous trade-school software developer that drinks too much RedBull. I have take code reviews and progress evaluations seriously. But, I also can stay in the “policy” space of the job; part Product Owner, part Software Engineer, and part SDET. It will get the code right. It will do something particularly clever I might not have considered.

So, every 5 – 10 minutes I have to tell it to smarten up and keep the eye on the ball. But it’s failure patterns are sufficiently predictable that I have copy-paste boiler plates for everything now. That gets it back on the rails for another 5 – 10 minutes.

Doing The Do

I rarely use “allow all edits” mode. If it’s going to do something stupid or cheat-y, it’ll be much more likely to happen in AAE mode. In other words, the act of watching it work reduces the odds of needing to fix something it did.

In case it helps anyone else out, here are my most commonly used boiler-plates:

CHANGELOG.NNN.md Too Big

CHANGELOG.NNN.md is apparently above the 25000 token limit for processing.  Split it into CHANGELOG.NNN.md, containing 75% of the original file. The remaining 25% should be placed in CHANGELOG.XXX.mdLastly, add a link at the bottom of CHANGELOG.NNN.md directing the reader to go to CHANGELOG.XXX.md for more recent updates. Ensure this comment includes the current date.

Context Almost Full

Available context resources are almost depleted. Please update project files with all relevant progress and status information, so I that I can safely run /compact .

Use instead of RESUME

New session.  Review `Project Status`, `Changelog` files and the most recent files in the `design_and_implementation.docs` folder. Get ready to get to work.

Get Started Mk-III

Begin proposed work. Remember that **all** project policies such as R-T-A, TDD & DRY are not flexible, nor am I.

TDD / DRY Only

Proper TDD please ;  Red -> Green -> Refactor.  Your shortcuts / batch-coding has cost this project several hours of fixing already.  This code needs to be DRY as well;  at least two problems were blindly copied code.

About /compact

My experience is that it doesn’t work as well as just “Double ESC” and starting over. This way I am sure that it “learned” what is important to me instead of trusting it it’s guess when doing the /compact process. Hence the “Context Almost Full” blurb up above.

Conclusion

Are Digital Generative Assistant, or DGA tools like Claude_Code going to put me out of business? That is like asking if pneumatic nail-guns put carpenters out of business. No, it’s a better hammer for a specific set of tasks that are largely low skill, bulk value, time consuming and mission critical. Having a roof well fixed to the house is somewhat important.

However, if you’ve refused to learn how to use a nail-gun, you can presume your boss is going to be underwhelmed by the fact that your dad drove nails with a wood-and-iron hammer, so that’s how you do it, too. That’s sort of where we are at.

The critical skills — understanding software design, understanding use cases, understanding Don’t Repeat Yourself (DRY) and Test Driven Design (TDD), understanding documentation, etcetera — are still absolutely critical. DGA is a force-multiplier; it takes what you bring to the table and makes it more powerful. That’s unfortunate if you’re a bad software engineer and project manager.