Articles and Posts

Large language models reward two behaviors that don’t translate well to humans: micro management and direct feedback bordering on incivility. This does not vindicate leading people this way. A machine doesn’t leave a working session better or worse for spending time with you. People do.

Working with LLM’s accelerates learning and multiplies effort. Collaborating with people accelerates learning and increases quality and ingenuity, while multiplying effort. I make sure I have plenty of both in my week.

With claude 4, use its reasoning threads. Read the stream it goes. When you see it struggling or about to take a wrong turn stop it. Correct/revert the files if necessary and tell it what you did and why and give it your reasoning on how to move forward. Then tell it to continue.

I’m polite in my prompts to AI because professionally, kindness brings out my best performance and because personally, I believe cruelty is an impulse that grows stronger with practice.

Co-authored an InfoQ article about what we’re learning using AI assisted tooling to speed legacy rewrites. Where the strengths of the tools best line up to bottlenecks in the effort.

AI Interventions to Reduce Cycle Time in Legacy Modernization:

Use AI tools to retrieve the conceptual design of legacy software to reduce the toil of lengthy up-front design.

Prompt to kick of development of a new feature:

I need to add another file output format using@OutputGenerator.cs though the bulk of the work should be a writer file in the @GraphDatabase namespace either there or in a kuzu namespace under it. I want to test drive this. So no creation or changes to production code without my saying yes to the change. You can create or modify and run tests as needed. The format I need to match is located in @graphdb-import-format

I’m making significant changes to my code. To reduce regressions — and avoid days lost troubleshooting — I instructed my code generation agent to create tests freely but only suggest code changes for my review. I introduce those changes myself, moving as much existing code as possible.

Language models rely on probabilistic sampling to generate responses. This enables them to produce unique outputs tailored to specific contexts but also means they lack strict fidelity and struggle to reproduce verbatim copies consistently. As a result, small variations in generated code can cause subtle breakage that is hard to detect and fix, even with test coverage.

Experimenting with adding test template into my integration test figure to see if it helps make my automated test generation more disciplined.

 // Test template - all tests must follow this pattern:
// 1. Create a tree instance that represents incremental complexity from the prior test.
// 2. Verify the additional complexity is setup correctly by asserting against that - don't create redundant assertions to prior tests.
// 3. Write to database - Only call WriteSymbolNodeToDatabase once per test for the root node.
// 4. Verify the assertion criteria is preserved in the database
// 5. Rebuild the tree
// 6. Verify the assertion criteria is maintained in the rebuilt tree

Is it because it’s Friday or because of some hidden change or because my context window has grown too large? My interactions with my code gen agent have lost many IQ points. I’ll try starting a new thread and see what happens…

A recurring instruction I add into my code generation prompts:

REMEMBER do not make a change to an implementation class until we have a failed unit or integration test for that class the validates the need for the change.

Me - REMEMBER there is no value in testing an unimplemented method throws a not implemented exception. We are test driving the implementation and at the end of that there will be no unimplemented exceptions.

Claude - You’re absolutely right - I apologize. Let’s write a proper test for the ContainingSymbol property that describes the actual behavior we want to implement:

Wrapping 3rd-party dependencies in interfaces reveals leaky abstractions. I build an abstract syntax tree, then render it. In render, I allowed access to underlying compiler symbols. Now I can’t. I’m discovering where I unnecessarily couple render to compiler implementation.