I build AI workflows and data tools for document heavy work, and I design them to stop and ask instead of guess.
By day I place representations and warranties insurance on M&A deals. I automated my side of that job with fifteen AI skills and an Excel tracker that I designed, tested and have run on every deal I have worked this year. By my estimate they save 2.5 to 5 hours per deal, and that time goes straight into getting the client report out faster. On the 35 deals we have taken to market this year, my final review has not caught a single extraction error. Several of those skills do nothing but check drafts against the source documents, so errors are caught before anything reaches a client. I write the specs, set the rules, test against real documents and own the results.
All placements are team placements with one colleague.
When a company is sold, the seller makes promises about the business in the purchase agreement. These are its representations and warranties. Representations and warranties insurance (RWI) pays the buyer if one of those promises turns out to be false, so the buyer can recover without suing the seller.
My job is running the market for that policy. I package the deal for insurers, collect their quotes, compare them, recommend one to the client, handle the revisions, and get the policy bound and filed. The skills and tracker on this page automate each of those steps.
Each skill is a written specification the AI follows, with its own reference rules and, where layout matters, Python scripts. Together they cover every stage of a placement. Select a skill to see what goes in, what it checks and what comes out.
In production Every deal I have worked in 2026 has run through these skills.
The time goes straight into turnaround: the client gets the quote summary report sooner after the last quote comes in.
Every skill went through the same four steps before it touched a live deal. 2025 was the build year: a full year of testing, feedback, steering and tightening the rules, which is why 2026 has run clean.
I wrote down each step of the task as my colleague and I actually performed it, including the checks we did by habit.
Before building, I agreed the exact deliverable with the producer and colleague who rely on it.
Each workflow ran against deals we had already completed by hand. It went live only when its output matched.
Each skill records its inputs, steps, outputs and checks, so someone else could run it.
Extraction is half the job. The numbers from every quote land in my tracker as individual inputs. From there I filter the market down to four finalists on price, coverage terms and underwriting experience, and the report inputs build themselves. I either paste those fields into the report or hand the tracker to the AI and let it fill them. The same workbook models large programs when a deal needs a tower of excess layers.
After the first round, finalists send revised indications as redlines while the purchase agreement keeps moving. The report has to change without carrying forward anything an insurer struck and without presenting old terms as new. Errors slipped through at this stage and reviews went back and forth, so I rebuilt it as one controlled workflow.
Every prior and revised indication, both agreement drafts and the last approved report, requested at once.
Compare prior and revised sources term by term before reading the report.
Recalculate affected figures and check each agreement comment against the latest draft.
One findings list with exact locations and replacement text. One approval.
Apply approved changes, highlight only current edits, keep the template intact.
Check the finished report visually for leftovers and layout defects.
Write the client update from the final report, limited to changes that matter.
Six made up indications from a ten insurer market run through the same steps the skills and the tracker perform: extract, track and select, QC, recommend, and the finished client report. A tower model for a larger deal follows. Change the limit, the finalists or the recommendation and everything downstream updates.
This demo replays the skills' rules in JavaScript so it runs in your browser. The real skills run on my firm's internal AI platform against real deal documents. New to RWI? Start with the primer.
State surplus lines forms are fixed layouts. Generic form fillers shrink long text until it is unreadable or let it run over the printed labels. My fillers place each value in a measured field box, center it on the font's real metrics, and raise an error instead of going below a minimum size.
Every field on the form has a rectangle measured from the blank PDF. Nothing is positioned by eye.
Each field has a preferred and a minimum size. If a value will not fit at the minimum, the run stops and asks for a source faithful abbreviation.
The finished file must be one page, with no live form fields, and must contain every value that went in. Any miss raises an error.
Signatures, execution dates and identifiers without a source are never typed in.
# Excerpt, rewritten for this page from my state form fillers. from pathlib import Path from pypdf import PdfReader from reportlab.pdfbase.pdfmetrics import stringWidth, getAscentDescent FONT = "Helvetica" PAGE_HEIGHT = 792 def fit_size(text, width, preferred, floor): """Largest size from preferred down to floor that fits the field.""" size = preferred while size > floor and stringWidth(text, FONT, size) > width: size = round(size - 0.1, 1) if stringWidth(text, FONT, size) > width: raise ValueError( f"{text!r} does not fit at the {floor} pt floor. " "Use a source faithful abbreviation or ask the broker." ) return size def draw_in_field(canvas, field, text, log, pad=1.5): """Place text in a measured field box, centered on real font metrics.""" if not text or not str(text).strip(): return # unsupported fields stay blank x0, y0, x1, y1 = FIELD_BOXES[field] # measured from the blank form preferred, floor = FONT_LIMITS[field] size = fit_size(text, (x1 - x0) - 2 * pad, preferred, floor) ascent, descent = getAscentDescent(FONT, size) bottom = PAGE_HEIGHT - y1 baseline = bottom + ((y1 - y0) - (ascent - descent)) / 2 - descent canvas.setFont(FONT, size) canvas.drawString(x0 + pad, baseline, text) log.append((field, size, text)) # every size is reported for review def verify_output(path, expected): """Fail closed: one page, no live fields, every value present.""" reader = PdfReader(str(Path(path))) if len(reader.pages) != 1: raise RuntimeError("Output must be exactly one page.") if reader.get_fields(): raise RuntimeError("Output still has interactive form fields.") text = reader.pages[0].extract_text() missing = [k for k, v in expected.items() if v and v not in text] if missing: raise RuntimeError(f"Values missing from output: {missing}")
Python · pypdf · reportlab · excerpt rewritten for this page
I am open to remote work, contract or full time. Three kinds of work match what this page shows.
Insurance, M&A and finance. I check AI output against the source documents, write the rules and failure cases it is judged by, and say exactly what is wrong and why.
See the QC stepFor document heavy work. I turn a manual process into specs with ranked sources, one approval gate and tests built from real mistakes, then run them on live work.
See the fifteen skillsDeterministic code where the model is weak: form filling, field placement, file naming and packaging, with hard limits that raise an error instead of guessing.
See the form code