Permit & License Consulting: Drafting and Requirement Triage with Claude Code

It was Friday afternoon, and I was staring at a spreadsheet for a contractor-license renewal, trying to confirm I had every document. “The proof of a qualifying technician’s experience — did I collect all of that yet?” The checklist a previous staffer had built in some homemade format ran 30 rows long, and even I couldn’t tell how far I’d gotten. When the client asked, “What else do you still need from me?”, I couldn’t answer on the spot. I said I’d call them back Monday. If you run a permit-and-license consulting practice, you’ve probably felt that exact awkwardness at least once.

License and permit work isn’t hard so much as it’s terrifying to get wrong. The requirements are a tangle of statute, agency operating policy, and your own memory of past cases, and rebuilding them from scratch every time eats hours. But it’s not fully boilerplate either, so you can’t just paste a template and be done. That “half-template, half-judgment” zone is exactly where a tool like Claude Code earns its keep by handling the prep work.

In this article I’ll walk through how to fold license drafting and requirement triage into your practice, using the exact steps I actually tried and prompts you can copy and paste.

Key takeaways

• For a licensing practice, the safest split is: AI does the prep, a human makes the final call. Keep that line sharp and you avoid most disasters.
• The fastest win is generating a requirement checklist per application type so you close the gaps in your intake questions before they bite you.
• PII is non-negotiable: swap real names, addresses, and ID numbers for placeholders before anything touches the AI. That one redaction step changes your risk profile dramatically.
• Below are three copy-paste prompt templates plus a check script that redacts common PII patterns mechanically.
• The final read of the law, whether a supporting document is required, and the final answer to your client are always decided by you. The AI output is a draft, full stop.

Where the time actually goes in a licensing practice

Let me set the reader picture first. This article is for the consultant running several license types with a small team: contractor licenses, waste-hauling permits, food-service permits, secondhand-dealer licenses, immigration filings, business-formation paperwork. Picture one or two assistants, five to fifteen cases in flight at once, and busy season where renewals and new filings pile up together.

A permit case usually flows like this:

1. Take the inquiry, size up the application type and rough requirements
2. Interview the client and hand them a document checklist
3. Review what comes in and chase down what’s missing
4. Draft the application, exhibits, and any justification statements
5. Submit at the agency counter or e-file, then handle correction notices
6. Post-approval follow-up (tracking renewal dates and so on)

Steps 2, 3, and 4 are the time sinks. The “size up the requirements and build the intake questions” step is subtly different for every case, yet I kept redoing it by hand, and a miss there feeds straight into rework downstream. Discovering, after the documents are already collected, that “actually you needed one more year of financial statements” hits your client’s trust, not just your schedule.

Here are the rework loops that show up over and over:

• Gaps in the intake questions split the document chase into two or three rounds
• Reusing an old similar case’s format means collecting documents you don’t need this time
• Writing each justification statement from scratch, only to land on nearly the same wording as last time
• On renewals, spending too long hunting down what changed since the prior filing

What to delegate to the AI, and what you must decide yourself

This is the most important part, so I’ll draw the line up front. Claude Code handles the prep; you handle the final judgment. Blur that boundary and you’ll trust some plausible-sounding requirement summary the AI wrote and walk straight into trouble.

Step	Safe to delegate to AI	The consultant decides
Requirement triage	List the requirement items per application type, draft the intake table	What’s actually required for this jurisdiction and this case
Document list	Generate a broad set of candidate exhibits	Whether each is needed given the facts; original vs. copy; expiration
Drafting	A first draft of justification statements; fill in boilerplate sections	Factual accuracy, no exaggeration, signature/seal decisions
Correction handling	Plain-language rewrite of the correction notice; organize response options	The final reply to the agency; what extra documents to add

The AI’s output is not an exact transcription of statute or agency policy. It’s a memory jog, a partner for catching gaps. The actual basis always comes from you checking primary sources. Hold that line and your drafting time drops sharply. If you’re new to handing work to a generative AI, I covered the basic mindset in Claude Code for non-engineers — worth reading alongside this.

Use case 1: Generate a requirement checklist per application type

This is the biggest win. The moment a new inquiry lands, tell the AI the application type and have it draft a requirement checklist. You cross-check it against your own template and confirm the gaps and the excess in about ten minutes.

For a new general contractor license, for example, have it build a table for each major heading — qualifying managing officer, qualifying technician, financial basis, integrity, disqualifying factors — listing “what to confirm” and “candidate documents to collect.” Then match the output against your own primary-source checklist and lock it down against the jurisdiction’s official guidance.

Here’s a prompt template you can copy:

You are an assistant at a permit-and-license consulting practice. For the
application below, produce a first draft of the requirement triage. A licensed
consultant does the final review, so prioritize broad coverage at the level of
"this is generally understood to be required," and avoid definitive claims.

# Application type
General contractor license (state-level, general classification, new application)

# What to output
1. For each major requirement heading (managing officer, qualifying technician,
   financial basis, integrity, disqualifying factors, etc.), a bullet list of
   points to confirm
2. Candidate exhibits to collect for each item (note original vs. copy if known)
3. A list of questions to ask the client during intake
4. Points to always verify in the jurisdiction's official guidance (where
   agency practice tends to vary)

# Constraints
- Where practice varies by jurisdiction, explicitly mark it "verify"
- Cite statute section numbers as reference only; write on the assumption that
  a human confirms the basis

The key is that last constraint: tell it “don’t be definitive — write ‘verify’.” Leave that out and the AI will confidently write “X is not required,” and if you miss that line, it’s dangerous. For the finer techniques of tightening up a prompt, I went deep in advanced prompt engineering.

Use case 2: Build the intake table and the client-facing document list

Once the requirement draft exists, shape it into something you can hand the client. Pass them a requirement list full of jargon and they won’t know what to gather. Convert it into a list that spells out what, from where, and in what state to obtain — like “Certificate of good standing (issued within the last 90 days, original).”

The trick here is specifying the output format:

Based on the requirement triage above, build a "documents we need you to prepare"
list I can hand directly to the client (a business owner unfamiliar with legal
terms).

# Format
- Table: document name / where to obtain / number of copies / notes (expiration, etc.)
- No jargon; name the source concretely (city office, county recorder, IRS, etc.)
- Add checkboxes (- [ ]) so the client can tick items off as they collect them

# Notes
- For anything whose necessity depends on the specifics, append "* verify"
- Don't be definitive about copy counts or expirations that vary by jurisdiction

This list cuts down the back-and-forth chasing. Because everything needed is visible at once, you avoid the drip-feed of “oh, and also this, and also that.”

Use case 3: Get a head start on justification-statement drafts

Waste-hauling permits and immigration renewals need a justification statement or a stated reason for the application. Writing those from scratch quietly eats time. The wording from past cases is more or less fixed, yet I kept reinventing it every time.

Here too, let the AI build the first draft. But the information you pass must contain no real names, addresses, or specific business names. Always run it through the redaction step described below first.

Using the fact memo below, draft a justification statement for a waste-hauling
permit application. Don't change the facts, don't exaggerate, keep it plain.

# Fact memo (already pseudonymized)
- Applicant: Company A (a firm running a freight business for 15 years)
- Motivation: A request from client Company B drove up demand for hauling
  construction debris
- Capacity: 3 vehicles; all drivers have completed hazardous-waste handling training
- Materials handled: rubble, waste plastics

# Constraints
- About 350 words, plain declarative tone
- Write nothing that isn't in the fact memo (don't fill gaps with guesses)
- Make signature / seal / date fields placeholders

Always check the resulting draft fact by fact, line by line, before using it. The AI tries to fill things in “plausibly,” so the thing to watch is whether it invented facts that weren’t in the memo.

What changed, before and after

Let me share the numbers so it lands. These are rough figures from my own desk and they swing with case difficulty, but as a benchmark:

Step	Before (by hand)	After (AI does the prep)
Requirement triage + intake table	~90 min	~30 min (including review)
Cleaning up the document list	~40 min	~10 min
First draft of the justification	~60 min	~20 min

Per case, roughly three hours shrank to a little over one. Run ten cases a month across new filings and renewals and that’s, by simple math, 15 to 20 hours back. What that’s worth per hour varies by practice, but reinvesting that time into client meetings and follow-up is a big deal. The thing to watch: what got cut is the prep time, not the review time. If anything, plan to review more carefully.

PII and security: the part you can’t skip

Skip this and everything else falls apart. By the nature of the job, a licensing consultant handles a flood of sensitive data — IDs, residency records, financial statements. Pasting that straight into an AI is an absolute no.

Here’s the minimum line to hold:

• Replace real names, addresses, dates of birth, government ID numbers, tax IDs, and specific business names with placeholders (Company A, Mr. B, City of ___) before anything goes to the AI.
• Don’t upload the actual images or PDFs of IDs, residency records, or registration certificates. Write only the necessary facts into a text memo and pass that.
• If you use it for real work, pick a contract form where your input data isn’t used for training (an API plan, or a plan whose data-retention settings you’ve confirmed). Review the terms of service and data handling once, properly, as a practice.
• Decide for yourself, before adoption, whether this stays within your confidentiality agreements and professional duty of confidentiality.

Pseudonymizing by hand actually leaks more, not less. So do it mechanically. The script below is a simple preprocessor that replaces typical PII patterns in text (email, phone numbers, long ID digit strings, and so on) with placeholders. It runs anywhere you have Node.js. Treat it as a first-pass filter before pasting, not a perfect anonymizer.

import { readFile, writeFile } from "node:fs/promises";

// Replacement rules: turn sensitive patterns into placeholders
const rules = [
  // Email addresses
  [/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, "[EMAIL]"],
  // Phone numbers (with/without separators, US-ish formats)
  [/\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g, "[PHONE]"],
  // SSN-like 9-digit strings
  [/\b\d{3}-?\d{2}-?\d{4}\b/g, "[ID-NUMBER]"],
  // Long ID / tax numbers (10+ digits)
  [/\b\d{10,}\b/g, "[NUMBER]"],
  // ZIP codes (5 or ZIP+4)
  [/\b\d{5}(?:-\d{4})?\b/g, "[ZIP]"],
];

const input = process.argv[2] || "./draft.txt";
const output = process.argv[3] || "./draft.masked.txt";

let text = await readFile(input, "utf8");
let hits = 0;
for (const [pattern, replacement] of rules) {
  text = text.replace(pattern, () => { hits++; return replacement; });
}
await writeFile(output, text, "utf8");
console.log(`Redacted ${hits} item(s) -> ${output}`);
console.log("Warning: names, addresses, and company names are NOT auto-removed. Always review by eye.");

You run it with node mask.mjs original-memo.txt masked.txt. That last warning message matters: free-text fields like names and addresses can’t be caught by a regex. So after the script runs, a human always strips the proper nouns by eye. Make it a two-stage gate. To make Claude Code itself enforce this redaction as a rule, use CLAUDE.md best practices to bake your practice’s policy into a config file — it gets far more consistent that way.

Checklist: the final pass before using an AI draft

When a draft comes back, run it through this before it “ships” (i.e., goes to the client or the agency):

• Confirmed no PII was sent, via both the redaction script and an eyeball pass
• Verified each requirement against the jurisdiction’s official guidance or the statute (primary source)
• Compared line by line to confirm the AI didn’t invent facts not in the memo
• Did not swallow any “not required” / “unnecessary” claim at face value
• Locked down original-vs-copy and expiration for each exhibit myself
• Reread the client-facing text to confirm no jargon slipped through

FAQ

Q. Can I trust the requirements the AI produced and file as-is? No. The AI’s output is a memory jog, not a basis. Always lock requirements down against the jurisdiction’s official guidance or the statute. Final responsibility rests with you, the consultant.

Q. Can I have it read an image of a client’s ID document? Don’t. Never pass the image or PDF itself. Transcribe only the necessary facts into a text memo, and even then redact real names and numbers before passing it. It looks like extra work, but it’s the minimum line for keeping confidentiality.

Q. Can an assistant who doesn’t know the legal jargon still use it? Yes. In fact, since you just ask in plain English, it’s well suited to having an assistant build the first draft. Getting started is easiest with the Claude Code getting started guide. Set the workflow so the consultant reviews the output, and your training cost drops too.

Q. Which application should I try first? Start with the high-volume ones that are mostly boilerplate. Contractor-license renewals, secondhand-dealer licenses, and food-service permits are where the payoff is easiest to feel. For highly case-specific filings like immigration, delegate only the requirement triage and handle the prose carefully.

Q. How do I keep the information current? Laws and agency policy change. The AI’s knowledge stops at its training cutoff, so always confirm effective dates and amendments against your government and agency official sources. For U.S. federal small-business licensing basics, the U.S. Small Business Administration is a solid primary-source starting point.

What I found when I actually tried it

I ran a fictional general contractor license (state, general classification, new application) end to end — requirement triage, intake table, document list. Every fact memo was pseudonymized and run through the redaction script before being passed.

I checked three things. First, the requirement checklist draft matched my own desk list about 90% of the time. The remaining 10% was jurisdiction-by-jurisdiction practice variation, and — as intended — those came out marked “verify,” so there were no dangerous definitive claims. Second, the client-facing document list broke the jargon down properly and came close to hand-it-over-as-is quality. Third, the justification draft tried, exactly once, to invent a business name not in the fact memo, so I stripped that by eye. Even with the “write nothing not in the memo” constraint, it isn’t perfect — which reconfirmed that the final line-by-line check is non-negotiable.

On the whole, prep time felt like it dropped by more than half, and I poured the freed-up time into the final requirement check. As a next step, pick one application your practice handles often and build its requirement-triage prompt from the template above. If you want to go further and streamline the whole workflow, see Claude Code productivity tips. And if you want to fold this into the whole practice — designing the operating rules together — our training and consulting can help you build the concrete flow.