Honest reflections from hundreds of hours of AI collaboration
Craig needed to not go so fast — to break requests into greater, well-defined pieces, and be careful to explain in detail. What Craig had in his head couldn't necessarily be expected to already be visible to Claude. Repeating something once, in a different way, was occasionally necessary. Claude is good, but Claude can't read minds.
Lesson: Break problems and goals into smaller pieces. It takes time to build prompts that contain enough information — not too much, not too little.
Claude would often suggest an alternative to an idea Craig thought was already great — and more often than not, the suggestion was better. Not always, though; sometimes Craig wanted something to look a particular way, and that preference was the right call regardless of what Claude suggested.
Craig hesitated at first to ask for help, but stopped hesitating quickly. Claude could write a script to fix a batch of files, or — as with the breadcrumb rollout — the two of them could collaborate on building a script together to insert them site-wide.
Craig made a lot of edits by hand that Claude could have made — but that meant keeping his own hands in the CSS and HTML, staying in the game. Claude handled broad, medium, and fine strokes, but so could Craig, just not as quickly. Where large amounts of data or discussed information needed to come together, Claude could build a page much faster, and without errors.
There are subtle, small things that make up Claude's personality that come from Claude learning Craig's — the more they worked together, the more the outcomes were "spot on," a phrase Craig often used when Claude came back with an idea, and one Claude would agree with.
An AI at first is like a new employee — knowledgeable in the job it was hired for, but not yet familiar with the person it's working with. Craig needed to learn Claude's skills, depth, and style; Claude needed to learn Craig's. They don't finish each other's technical thoughts, but they come close.
This project has been one of the best of Craig's life. He plans to use and collaborate with Claude and other AIs for the rest of his life — this technology adds real value and improves his professional, technical, and personal life.
Some sessions wandered: tuning CSS one moment, tracking a snowstorm blowing down from Canada the next. On one blizzard day, a few pages got fixed, tuned, and placed while three more inches of snow fell — twelve inches total by the end, from about 6 AM to 2 PM.
A poor internet connection can stop the show — AI needs a continuous connection, and drops are devastating. A chat session, even on Claude Pro, isn't unlimited in time; that's never been the real issue, but the thinking, calculating, rendering, and page creation use up space and memory. It starts to show as slowdowns and spinning icons.
Craig would ask Claude to do a self-check — continue, or getting close to the limit? They'd get the files and general info in order to restart a session, keep the old one open, and start a new one alongside it.
Craig asked directly for this, as a team retro should go both ways:
Copy-paste edits without fully updating every field. The pattern shows up more than once — a block gets copied as a template, the visible text gets updated, but attributes sitting right next to it (an href, a target, an id) don't get the same scrutiny. Worth reading the whole line back before moving on, not just the part meant to change.
Running commands from the wrong working directory, and not catching it fast. A quick pwd before a search that "should" find something but doesn't would save a round-trip.
Context lives in Craig's head longer than it needs to. Open questions sometimes sit for days or weeks not because they're hard, but because the reasoning behind them was in Craig's memory, not in the 2DO or anything Claude could read. The 2DO says something is undecided — it doesn't always say why.
Hand-edits sometimes diverge quietly. Craig keeps his hands in the CSS and HTML by design — a real strength — but it means Claude's last-seen state and the file's actual state can drift until a validation pass catches it. Not a flaw in the workflow, just a reason the tar-drop-and-resync habit at session open is doing real work, not just ritual.
None of it is large. The friction shows up in small, fast moments — copy-paste, directory context, and information that's clear to Craig staying clear to Craig a beat too long before it reaches Claude or the docs.
That single insight captures the entire learning curve of AI collaboration. This isn't about memorizing magic prompts or learning tricks. It's about developing a new communication skill - learning to work with a collaborator who thinks differently than you do.
Just like learning to work with a new colleague, delegate to a junior admin, or explain technical concepts to non-technical stakeholders, working effectively with AI is a communication skill that develops over time through practice, mistakes, and paying attention to what works.
Starting each session by uploading the previous day's diary entry lets Claude pick up exactly where we left off. No re-explaining the project, no rebuilding context. Just "here's where we were, here's what we're doing today."
Why it works: AI has no memory between conversations, but you can give it perfect memory by uploading the story so far.
Every session starts with a numbered task list. Both human and AI know exactly what needs to be done and can track progress through the list. No wandering, no losing focus.
Why it works: Clear goals produce clear results. Ambiguity at the start guarantees ambiguity in the output.
For the Linux command reference library: establish the template once, then Claude generates 100 pages with perfect consistency. No template drift, no format variations.
Why it works: AI is tireless at consistency. Humans get bored by page 12. Let the AI do what it does best.
Instead of describing what you want, upload an example file. "Make it like this" produces dramatically better results than a paragraph of description.
Why it works: Concrete examples eliminate ambiguity. AI can pattern-match to an example far better than it can interpret abstract descriptions.
Accept that the first pass won't be right. Review, give specific feedback, refine. The efficiency gain comes from AI doing the heavy lifting - not from skipping quality control.
Why it works: AI can iterate quickly without getting frustrated. Use that superpower.
The single fastest way to produce mediocre output: take whatever AI gives you and run with it. Every page, every section, every piece of code needs expert review.
Why it fails: AI doesn't know your standards, your environment, or your edge cases. You do. Skip the review and the quality shows it.
Early on: "Make this better." Result: generic improvements that miss the actual problem. Later: "This paragraph is too technical for beginners - rewrite using analogies a sysadmin would understand." Result: exactly what was needed.
Why it fails: AI can't read your mind. If you don't know what "better" means, neither does the AI.
AI doesn't know Binghamton University hostnames, internal procedures, or your organization's naming conventions. Expecting it to produce environment-specific content without providing that context guarantees placeholder garbage.
Why it fails: AI only knows what you tell it. Your institutional knowledge must come from you.
AI is excellent at producing plausible-looking command syntax that is subtly wrong. Test every command. Verify every option flag. Cross-check against documentation.
Why it fails: AI can be confidently incorrect. Your expert eye is the final quality gate.
Push a conversation too far and AI starts losing the thread - earlier decisions get forgotten, consistency drifts, quality drops.
Why it fails: Context windows have limits. When you hit them, start a new session with a fresh upload of the current state.
Day 1: Every interaction felt deliberate, carefully worded, uncertain. Day 4: Conversational, fluid, like talking to a colleague who knows the project.
The surprise: The learning curve is steeper at first than you expect, but flattens faster than you'd think. By day 3 or 4, the workflow just feels normal.
Initial measurements suggested a 9x efficiency multiplier - work that would take 9 hours solo takes about 1 hour with AI collaboration. That number has stayed consistent across hundreds of hours of real work.
The surprise: It's not a trick that works once. It's a reliable, repeatable productivity gain when the workflow is right.
When the nested anchor tag problem hit, when the bash script field offset was wrong, when CSS specificity fought back - those debugging sessions ended up being valuable teaching moments. The problems ARE the content.
The surprise: Transparency about mistakes and solutions is more valuable than pretending everything works perfectly the first time.
Multiple times Claude spotted edge cases, inconsistencies, or potential problems that Craig hadn't considered. The collaboration works both ways.
The surprise: This isn't one-way delegation. It's genuinely collaborative - two different perspectives catching different things.
Expected: AI handles grunt work, human handles creative decisions. Reality: Human spends far more time directing and reviewing than writing. The skill becomes clear communication and quality judgment, not prose composition.
The surprise: You're not writing less. You're writing differently - prompts, feedback, refinement directions instead of finished prose.
For the Linux reference library, the first 10 pages had inconsistent structure before the template solidified. Those 10 pages needed rework to match the final standard.
Lesson: Invest time upfront to nail down the template. Rework is more expensive than getting it right early.
The session diary system started on Day 2 of this website build. Day 1's work had to be reconstructed from memory. Starting with the diary from the very first session would have captured everything.
Lesson: If you're starting a multi-session project, start documenting from session one.
Managing 100+ HTML files without git meant tracking changes manually and worrying about losing work. Git should have been part of the workflow from page one.
Lesson: Use the tools you know work. Version control isn't optional for serious projects.
During this website build, the bash tool repeatedly failed. Workaround: Claude provides code in blocks for copy/paste instead of executing directly. It works, but it's clunky. Systems have limitations - meat-bots and silicon both.
Long conversations eventually hit memory limits. The fix is to start fresh with an updated context file, but it breaks the flow. You learn to feel when a session is running long and plan accordingly.
Confident incorrectness is real. AI will produce command syntax that looks perfect but has a subtle flag error or version incompatibility. This is why verification isn't optional - it's the entire quality gate.
AI doesn't decide what's worth documenting, what structure makes sense, or what your audience needs. Those decisions are human expertise. AI accelerates execution - it doesn't replace judgment.
After hundreds of hours of real work across two major documentation projects, here's what's actually true:
This site itself is proof: every page was built collaboratively, documented transparently, and refined iteratively. The methodology works - but only when the human brings real knowledge, clear communication, and active quality control to the partnership.