I keep a maintenance log for a small off-grid battery bank that runs a workshop and a few backup circuits in a 1940s house. The log isn’t glamorous. It’s a running record of voltage readings, equalization dates, water levels, terminal torque checks, and the occasional “weird smell near the charge controller” note. I’ve maintained it by hand for four years because I don’t trust my memory when a battery string starts drifting or a connection corrodes quietly over a winter.
Last month I decided to test whether a free AI script generator could take over the writing part—not the measurements, not the physical inspection, just the documentation. The idea was simple: feed the generator a set of raw readings and observations each week, ask it to produce a structured maintenance entry, and see whether the output was accurate enough to replace or supplement my handwritten log. I used the script generator built into the Unsloppy AI Writing App, a tool that promised structured, formatted output without requiring me to learn prompt engineering. I wanted something that could produce a consistent log format, not a creative narrative.
What I got was a month of entries that looked professional, followed a template, and occasionally inserted errors that would have mattered for safety, warranty claims, and long-term battery health. Here’s what the generator got right, where it drifted, and why I’m not handing over the logbook yet.
Why Maintenance Documentation Matters More Than It Looks
Before the test, it’s worth stating why a maintenance log isn’t just bureaucratic paperwork. For lead-acid battery banks—flooded, AGM, or gel—manufacturers typically require documented maintenance for warranty coverage. Trojan’s warranty terms, for example, specify that “records of specific gravity readings, water additions, and equalization charges must be maintained.” If a cell fails prematurely and you can’t produce a dated log, the warranty claim often dies there.
Beyond warranties, a log is a diagnostic tool. A single low voltage reading doesn’t tell you much. A sequence of readings where one battery in a string consistently sags 0.2 V below its neighbors over three weeks tells you something about internal resistance, sulfation, or a bad inter-cell connection. The pattern matters, and the pattern only exists if the log is consistent and accurate.
Finally, there’s a safety dimension. A flooded lead-acid battery that’s been overcharged or under-watered can vent hydrogen. A log entry that misstates whether equalization was completed or whether water was added after charging (not before) could lead someone to skip a step that prevents a thermal event. Documentation errors in technical systems aren’t just typos—they’re instructions that someone might follow.
The Setup: What I Fed the Generator and What I Asked For
My system is modest: four 6 V flooded lead-acid batteries in series-parallel for a 12 V nominal bank, a 40 A MPPT charge controller, and a 2,000 W inverter-charger. I take readings every Saturday morning: voltage per battery, specific gravity per cell (using a refractometer), water levels, terminal temperatures (infrared thermometer), and any visual notes. I also log equalization events, load tests, and ambient temperature in the battery enclosure.
Each week I gave the AI script generator the same raw data I’d normally write into my notebook, plus a one-sentence context note like “equalized bank on Thursday” or “noticed slight corrosion on battery 3 negative terminal.” I asked it to produce a structured maintenance log entry with these sections: date and time, ambient conditions, per-battery voltage and specific gravity, actions taken, observations, and a summary assessment of bank health. I didn’t provide a template—I wanted to see what structure the generator defaulted to.
I ran this for four consecutive weeks in late spring, a period with moderate temperatures and no extreme charging events. The system was in normal float service with occasional inverter loads for power tools.
Week 1: The Output Looked Better Than My Handwriting—and Introduced a Phantom Equalization
The first entry arrived formatted as a clean, sectioned document with bold headers, consistent date formatting, and a summary line that read like a professional service report. It correctly transcribed the voltage readings I’d supplied: Battery 1 at 6.37 V, Battery 2 at 6.35 V, Battery 3 at 6.34 V, Battery 4 at 6.36 V. Specific gravity values were listed correctly per cell.
Then I read the “Actions Taken” section. It stated: “Performed equalization charge on all batteries. Verified specific gravity rose to 1.275+ on all cells post-equalization.” I had not equalized that week. I had not told the generator I equalized. The raw data I supplied showed specific gravity values between 1.265 and 1.270—normal float range, not post-equalization numbers. The generator had inferred an equalization event from nothing.
This is the kind of error that matters. If I’d filed that entry without checking and later needed to prove equalization frequency for a warranty claim, I’d have a fabricated record. If someone else maintained the bank using that log, they might skip a needed equalization because the log falsely showed one had just occurred. The generator didn’t “hallucinate” in the sense of inventing numbers—it invented an action, and it did so in a section where accuracy is non-negotiable.
Week 2: Correct Data, Wrong Diagnostic Conclusion
Week two’s raw data showed a slight voltage spread: Battery 3 was at 6.31 V while the others sat at 6.36–6.37 V. The specific gravity on one cell of Battery 3 was 1.255, about 15 points below the others. My handwritten note said: “Battery 3 cell 2 SG low—monitor, possible sulfation starting. Will check again next week before deciding on equalization.”
The AI-generated entry transcribed the numbers correctly. The summary assessment, however, read: “Bank is balanced and healthy. All batteries within normal operating range. No action required.”
A 0.06 V spread and a 15-point specific gravity gap on a flooded lead-acid bank in float service is not “balanced and healthy.” It’s an early warning. The generator had no context for what constitutes a normal spread in this chemistry, this bank size, and this age. It applied a generic “within range” heuristic that would have buried a real degradation signal.
This is where the difference between a template-filling tool and a diagnostic log becomes clear. A human maintainer knows that a trend matters more than a single reading. The generator produced a snapshot summary that was factually wrong in its conclusion, even though the input numbers were faithfully reproduced.
Week 3: The Generator Rewrote My Observation and Lost the Specifics
In week three I noted corrosion on the negative terminal of Battery 3—a greenish-white powder forming around the lug. I cleaned it, applied corrosion inhibitor, and retorqued the connection to 95 in-lb. My raw input said: “Battery 3 negative terminal: light corrosion, cleaned with wire brush, applied NO-OX-ID, retorqued to 95 in-lb. Terminal temp normal after 30 min under 40 A load.”
The AI entry summarized this as: “Inspected and cleaned battery terminals. All connections secure.”
That summary is useless for future diagnostics. It doesn’t say which battery, which terminal, what was found, what was done, or what the torque value was. If corrosion returns in three months, I can’t look back at that entry and know whether it’s the same terminal or a new problem. The generator optimized for brevity and generic professionalism, stripping out the specifics that make a maintenance log function as a historical record.
This pattern—correct transcription of supplied numbers, but lossy summarization of qualitative observations—appeared in all four weeks. The generator treated observations as prose to be polished, not as data to be preserved.
Week 4: A Formatting Error That Could Confuse a Future Reader
The final week’s entry introduced a structural problem. I had taken specific gravity readings for all 12 cells (three per battery) and listed them in order: B1C1, B1C2, B1C3, B2C1, etc. The generator produced a table that shifted the alignment: Battery 2’s cell 3 reading appeared under Battery 3’s column. A reader glancing at the table would think Battery 3 had a cell at 1.270 and another at 1.255, when in fact those readings belonged to different batteries.
This was a formatting error, not a content hallucination, but its effect was the same: the log misrepresented the physical state of the bank. If I’d used that table to decide which battery to equalize or replace, I’d have targeted the wrong unit.
I also noticed that the generator consistently omitted the ambient temperature reading I supplied each week. Temperature matters for voltage interpretation—a 6.37 V reading at 10°C means something different than 6.37 V at 30°C. The generator didn’t flag the omission; it just dropped the field silently.
What the Generator Got Right
It’s not all failure. The generator produced a consistent structure every week. Date formats were uniform. Section headers were predictable. The voltage and specific gravity numbers I supplied were transcribed accurately in three of four weeks (the week-four table shift being the exception). The output was readable and would look credible to someone who didn’t know the system.
For a use case where the log is purely a formality—say, a landlord who needs to show “maintenance was performed” without anyone ever acting on the log—the generator’s output might be sufficient. It creates a dated, structured record that checks a box. But that’s not what most off-grid system owners need. They need a log that helps them make decisions.
Where AI-Generated Technical Documentation Fails in Ways That Matter
After four weeks, I see three failure modes that are probably generalizable beyond my battery bank:
1. Inference without evidence. The generator filled gaps with plausible-sounding actions that didn’t happen. In technical documentation, a missing data point should remain missing, not be replaced by a statistically likely entry. A log that says you equalized when you didn’t is worse than a log with a blank line.
2. Lossy summarization of qualitative observations. The generator treated my corrosion note as text to be condensed, not as a structured observation to be preserved. Maintenance logs need specificity: which component, what condition, what action, what torque, what temperature. General summaries are not backward-searchable.
3. No domain-specific thresholds. The generator didn’t know that a 0.06 V spread on a 6 V flooded battery is worth noting, or that specific gravity gaps of 15 points warrant monitoring. It applied generic “within range” logic that would have normalized an early failure signal. This is the core problem with using general-purpose language models for domain-specific technical writing: they don’t know what’s abnormal in your context.
The Authors Guild, in its AI Best Practices for Authors, notes that “AI outputs are generic mashups of pre-existing works ingested during training” and that “when you claim authorship in a work, it means you are responsible for its content.” That responsibility lands differently when the content is a maintenance log that someone might use to decide whether a battery string is safe to equalize. The Guild’s guidance is aimed at creative writers, but the principle transfers directly: if you put your name on AI-generated technical documentation, you own the errors.
What a Script Formatting Standard Reveals About the Output
I also checked the generator’s output against basic script formatting conventions, using StudioBinder’s screenplay formatting guide as a reference. Not because a maintenance log is a screenplay, but because the generator markets itself as a script generator, and I wanted to see whether it could handle structured formatting at all.
The output used consistent headers and section breaks, but it didn’t follow any recognizable industry template for technical documentation—no standard log fields, no metadata block, no version or revision tracking. It produced something that looked like a formatted document but wasn’t built on a spec. For a maintenance log, that’s fine if you only need readability. For anything that might be audited, submitted for a warranty claim, or handed to a third-party technician, the lack of a standard structure is a liability.
When an AI Log Generator Might Actually Be Useful
I’m not saying the tool has no place. If you already keep a detailed handwritten or spreadsheet log and you want a formatted, shareable version for a landlord, an insurer, or a less technical family member, a generator could save you 15 minutes a week. The key is that you must review every line before filing it. The generator is a formatting assistant, not a documentation author.
There’s also a narrow use case for generating a blank template. If you ask the generator to produce a structured log format with the fields you specify, and then you fill it in manually, you avoid the inference and summarization problems entirely. The generator becomes a layout tool, not a writer.
What I wouldn’t do is let the generator write entries unsupervised and file them without review. The error rate over four weeks—one invented action, one wrong diagnostic conclusion, one lossy observation summary, one table misalignment, and consistent omission of ambient temperature—is too high for a document that has safety and warranty implications.
The Bottom Line for Small-System Owners
If you maintain a battery bank, a solar array, a rainwater system, or any clean-energy installation where the log matters for safety, warranty, or diagnostics, an AI script generator can format your notes. It shouldn’t write them. The gap between “looks professional” and “is accurate” is wide, and in technical documentation, the gap is where damage hides.
My handwritten log is slower, messier, and harder to share. It’s also correct. For now, I’ll keep writing it myself and maybe use a generator to produce a clean PDF version for the file folder—after I’ve checked every entry against my notebook. The tool is useful the way a typewriter is useful: it makes the page look better, but the words still have to come from someone who was there.