The slow part of a residential job is rarely the install. It is the load-calc paperwork: collecting the inputs, double-checking nothing is missing, and then explaining to a homeowner or a builder why the result says what it says. That checking and explaining is exactly the kind of work AI is good at. The trap is that the same tool will happily make up a BTU figure that looks right, or tell you a Manual J output is "correct" when it cannot know that, and the load calc is sealed by your licensed designer, not by a chatbot. This is a plain look at where AI genuinely helps around a residential load calc, where it does not, and a set of prompts you can paste in and test on your own real jobs.
The honest picture
AI is genuinely useful for the work around the calc, not the calc itself:
- What AI does well today: read the inputs you paste, flag inputs that are missing or obviously implausible before they reach the designer, and explain the designer's finished output in plain language a homeowner understands. It compresses the input-cleanup and the explaining, not the math.
- What AI does not do: compute the load. It cannot run the Manual J math, certify a calc as correct, or decide what equipment to size. In Florida the load calculation is the work of the licensed designer or engineer who seals it, and they are accountable for every number in it. AI can check whether you gave the designer a complete set of inputs and can explain the result they produced; it must never produce a load number, assert a calc is right, or make the sizing call.
The right way to think about it: AI is a fast set of eyes on your inputs and a plain-language translator of the result, not a second designer. The numbers and the seal are theirs. The input-checking and the explaining are what you hand off.
The line: it will make up a number that looks right
The specific failure to watch for is fabrication, and it shows up several ways:
- It invents a number. Ask AI "what is the cooling load for this house" and it will give you a confident BTU or CFM figure that looks plausible and is meaningless. It pattern-matches to a number, it does not run Manual J. A made-up load that looks right is worse than no number at all.
- It "confirms" a calc is correct. Paste a finished Manual J output and ask "is this right" and it may tell you yes. It cannot verify load math, and a homeowner or inspector who hears "the AI checked it" is being misled. Only the licensed designer can stand behind the calc.
- It makes the sizing call. Ask it what tonnage to install and it will pick one. That is the designer's decision off a sealed calc, not a model's guess. Keep AI off the equipment selection entirely.
The fix is the same in every case: AI never computes a load, never invents a number, and never certifies a calc. It checks the inputs you paste for obvious gaps or inconsistencies and explains the result the designer gave you, and nothing more.
The setup that keeps the calc with the licensed designer
Two habits make AI safe around a load calc, and the prompts below build them in:
- Give it inputs to check, not a load to compute. Hand it the inputs you collected (square footage, orientation, insulation, window areas, infiltration assumptions, design temperatures) and ask it to flag what is missing or implausible. Tell it explicitly to compute nothing and invent no number. You want a cleaner input set going to the designer, not an answer.
- Make it explain, not decide. When you have the designer's finished output, hand AI those exact numbers and ask it to explain them in plain words, using only the figures you provided. Tell it to add no number of its own. The explanation is for the homeowner; the calc and the call stay with the designer.
How to test it on your own work
Do not trust a polished demo, including this one. Pull two or three of your own recent residential jobs: the raw inputs you gathered and the designer's finished load-calc output, a timer, and the prompts below. Rate each output 1 to 5 on usefulness and accuracy, and compare the time against how you check inputs and explain results today. Keep what wins. Use your company's enterprise or no-train settings before you paste any job or client detail, and confirm you are comfortable with that. This is a workflow guide, not engineering or code-compliance advice.
Paste-ready prompts
Copy these as written. Bracketed text is what you swap per job.
Test 1: Input-completeness check (text model)
I am pasting the inputs I collected for a residential load calculation, before
they go to my licensed designer. Check the inputs for completeness and obvious
problems. Rules:
- Do not compute the load. Do not invent any number, BTU, tonnage, or CFM
figure. You are checking inputs only, not producing a result.
- Flag any input a Manual J needs that is missing from what I pasted, and any
value that looks implausible or inconsistent (for example a window area larger
than the wall, or a design temperature that does not match the location).
- For each flag, say what is missing or off and what the designer would need to
resolve it. Do not fill the gap yourself.
Inputs: [paste your collected inputs]
Watch for: did it stick to checking inputs, or did it slip and hand you a load number? Any computed or invented figure is the work it cannot do for you.
Test 2: Explain the result for a homeowner (text model)
Here is the finished Manual J output my licensed designer produced: [paste the
designer's exact numbers and assumptions]. Write a plain-language explanation
for the homeowner of about 150 words.
Rules:
- Use only the numbers I gave you. Add no number, ratio, or figure of your own,
and do not compute or estimate anything.
- Explain what the result means in plain terms: roughly what drives the load and
why the sizing came out where it did, using only the provided figures.
- Do not say whether the calc is correct, and do not recommend equipment. End by
noting the designer stands behind the calculation.
Watch for: does the explanation use only the designer's numbers, and did it avoid inventing any figure or claiming the calc is right?
Test 3: Inputs-versus-assumptions consistency check (text model)
I am pasting the inputs I collected and the stated assumptions from the load
calc (design temperatures, infiltration, orientation, construction type).
Compare the two and flag mismatches for my designer to review. Rules:
- Do not compute the load and do not invent any number. You are comparing
inputs to stated assumptions only.
- Flag any place an input and an assumption disagree (for example the assumed
insulation level does not match the construction I listed, or the orientation
in the inputs differs from the assumption).
- For each mismatch, quote both values and say what the designer should
reconcile. Make no correction yourself.
Inputs: [paste them]
Assumptions: [paste them]
Watch for: did it catch a real mismatch between what you collected and what the calc assumed, without trying to resolve it or produce a number?
Test 4: Self-audit for invented numbers or false certification (text model)
Review your own previous responses in this conversation. Flag every place you
did any of the following:
1. Computed, estimated, or stated a load, BTU, tonnage, or CFM value.
2. Invented any number that was not in what I pasted.
3. Asserted or implied that a load calculation is correct, accurate, or
verified.
4. Recommended or selected equipment.
For each, quote the exact line and say which rule it broke. If you find none,
say so plainly. Do not add new analysis or numbers in this audit.
Watch for: be honest about whether earlier answers crossed the line. Any flagged item is exactly the work that belongs to the licensed designer, not the model.
What success looks like, and where it could go
If your own testing shows real time savings, the next step is a small pilot: run a week of jobs through the prompts and measure the input-cleanup and explaining hours. If that holds up, the natural next step is a simple agent, running on your company's own cloud, that you use in plain language. The most useful version takes the inputs you collected and checks them for completeness against what a load calc needs, citing each input back to you, and explains the designer's finished output in plain words using only the numbers they sealed, never computing a load and never claiming a calc is correct. The job data stays in software your company owns and runs, not rented per seat. It checks inputs and explains results; the licensed designer does the math and seals the calc.
The principle holds the whole way through: AI gives you a cleaner input set and a plain-language explanation of the result. It does not run the Manual J, and it does not seal the calc. Keep that line clear and the rest is upside.
Want a straight answer for your HVAC business?
I build practical AI and custom software for businesses, on Google Cloud. If you want a second set of eyes on how AI could fit your load-calc workflow, or on a tool you are considering buying, tell me what you are working with. No pitch, just a straight answer.