Writing a foundation or grant application with AI

Note: general recommendations only, not professional advice. You are responsible for checking before use. Verify eligibility and terms with the funder, and the budget with an accountant. The full text is at the end.

Who this is for

For a nonprofit director, a development coordinator or a board member who writes applications to foundations, government ministries or local authorities. No technical background needed. You need a Claude or ChatGPT account, the full call for proposals and your organization's documents.

This playbook starts after you've already decided to apply. How to find calls for proposals and screen them is covered in the playbook "How a nonprofit finds grant calls and applies with AI".

The problem in three lines

Every foundation asks for a different structure, a different length and different documents. Text that AI writes "from scratch" sounds good, but it's full of targets and numbers nobody in the organization committed to. And under deadline pressure the small things get forgotten: a missing appendix, a budget that doesn't match the text, a signature nobody collected.

The method in 7 steps

Step 1: Gather raw material before you write a word

What to do: Prepare one folder with everything the application will rely on. The AI writes only from what's in the folder.

How: The folder should contain:

• The full call for proposals, including appendices, forms, published questions and answers, and the scoring criteria document if there is one.
• An organization card: mission, populations, area of activity, annual budget, team, year founded, good-governance certificate.
• Verified data: participant numbers, results from past measurements, quotes from feedback. Next to every figure: where it's from and what year.
• Past applications you've submitted, including rejected ones. They teach the AI how the organization writes.
• A draft budget for the program, even if it's still rough.

Common mistake: Giving the AI only the link to the call. It will read part of it, guess the rest, and never see the appendices.

Step 2: Break the call down into a table

What to do: Before writing, ask the AI to break the call down into one table. That table is the map for all the work.

How: The table has four parts:

1. Threshold conditions: who may apply, mandatory documents, limits on amount and period.
2. Scoring criteria: every criterion, and its weight if published. This is where you learn what's worth spending words on.
3. Required structure: which sections, in what order, and the length limit of each (words, characters or pages).
4. Technical: submission date and time, submission method (online system, email), file format, language.

Next to every row, ask for a verbatim quote from the call. A row without a quote is checked by hand.

Common mistake: Writing to a "standard" application structure when the foundation asked for a different order. Reviewers read in their own order, and look for the answers where they asked for them.

Step 3: The application skeleton

What to do: Build a skeleton: a heading for each section in the call's order, and under each heading three to five points on what will be written there and from which source.

How: If the foundation didn't define a structure, these are the sections that appear in most applications:

• Summary: in one sentence, what the problem is, what you'll do, for whom and what will change.
• The need: what the problem is, for whom, and how you know. One good figure with a source beats five generic ones.
• The population: who will take part, how many, and how they'll reach you.
• The program: the activities, the timeline and who carries them out.
• Targets and indicators: what will be counted (outputs) and what will change for participants (outcomes), and how you'll measure it.
• The organization and team: why you're the right ones to do this.
• Budget: expenses by line, and other sources of money.
• Sustainability: what happens when the grant ends.

Mark in the skeleton every point that has no source in the folder. That's your list of questions for the team.

Common mistake: Skipping the skeleton and asking for full text. A skeleton takes ten minutes to check, full text takes an hour. Structural mistakes are found faster in the skeleton.

Step 4: Write section by section, only from the facts

What to do: Write each section in a separate conversation or separate request, with the skeleton, the table from step 2 and the materials relevant to that section.

How:

• Give the length limit in words. AI tends to write too much.
• Ask that anything missing stays in the text as a visible marker, for example [to complete: number of participants last year].
• Explicitly forbid inventing numbers, partners, quotes or results.
• Give an excerpt from a past application as a style sample, so the text sounds like the organization.
• Ask for plain language and short sentences. Reviewers read dozens of applications.

After each section, read it yourself and mark every claim you can't back up. That claim either goes or gets a source.

Common mistake: Leaving phrasing like "the program will bring about significant change". It tells the reviewer nothing. Write exactly what will change and for whom.

Step 5: Checking fit against the scoring criteria

What to do: When the draft is complete, give the AI the role of a strict reviewer at the foundation, and ask it to score the application by the criteria from the table.

How: For each criterion, ask for:

• A score on the foundation's scale, if published.
• A quote from the application that answers the criterion. No quote, no answer.
• What's missing or weak, and where in the text it should be strengthened.

Also ask it to check that every requirement in the call is answered, and that every length limit is kept.

Run this check in a new conversation, without the writing history. That way the reviewer doesn't "know" what you meant to write, and reads only what's written.

Common mistake: Asking it to "improve the application" instead of "check the application". General improvement adds words and flourishes. A check shows you what's missing, and you decide.

Step 6: A budget and a text that tell the same story

What to do: Check that every activity in the text appears in the budget, and that every budget line is explained in the text.

How:

• Give the AI the budget and the text, and ask for a cross-check table: activity, where it is in the text, which budget line, whether the numbers match (participants, sessions, months).
• People build the budget itself, not AI. The AI only points out gaps.
• Check against the call which expenses are allowed, whether there's a cap on overhead, and whether matching money is required.
• Review the budget, the salary lines and the financial reporting method with the organization's accountant.

Common mistake: Changing the number of participants in the text at the last minute and forgetting to update the budget. A reviewer who sees 120 participants in the text and 80 in the budget loses trust in the whole application.

Step 7: A manual check before submitting

What to do: A day or two before the deadline, one person goes through a fixed list. This check is not handed to AI.

How: The full list is in the checklist below. The most important items:

• Every number, name, date and amount is checked against the source.
• No [to complete] is left in the text.
• Every mandatory document is attached, valid, and signed by the authorized signatories.
• Length and format limits were kept.
• Every commitment in the text is something the organization can really meet, and someone on the team knows they're responsible for it.
• Submit at least a day ahead, not an hour ahead. Submission systems get stuck.

Keep a copy of everything you submitted, exactly as submitted.

Common mistake: Relying on the AI having "checked everything". It doesn't see the scanned documents, doesn't know who the authorized signatories are, and doesn't know what the board approved.

Ready-made prompts

Replace whatever is in square brackets. Paste the call as full text or attach it as a file, not as a link.

Here is a full call for proposals, including appendices: [paste or attach].
Break it down into a table in four parts: 1) threshold conditions, 2) scoring criteria and the weight of each, 3) required structure: sections, order and length limit per section, 4) technical: date and time, submission method, format, documents.
For each row add a verbatim quote from the text. If something doesn't appear, write "not stated". Don't fill in from guesswork.
At the end, list up to 5 questions worth asking the funder before you start.

Based on the call table: [table] and the organization card: [card], build a skeleton for the application.
A heading for each section, in the order the call asks for. Under each heading 3 to 5 points: what will be written and from which source in our materials.
Mark every point with no source as [missing: ...]. Don't write full text at this stage.

Write the section "[section name]" for the application, up to [number] words.
Use only these facts: [paste the points from the skeleton and the relevant materials].
Leave anything missing as [to complete: ...]. Don't invent numbers, partners, quotes or results.
Write like this excerpt from one of our past applications: [paste excerpt]. Plain language, short sentences, no superlatives.

This section is too long: [paste]. The limit is [number] words.
Shorten it without dropping any fact, number or commitment. Remove repetition, introductions and adjectives.
After the shortened text, list what you removed.

You are a strict reviewer at [foundation name or type of body]. Here are the scoring criteria: [paste from the table]. Here is the application: [paste].
For each criterion: a score on the scale [scale], a quote from the application that answers it, and what is missing or weak. If no quote answers it, write "not answered".
Also: does each section meet its length limit? Is there a requirement in the call that wasn't answered?
Don't rewrite the application. Only check it.

Here is the application text: [paste] and here is the budget: [paste table].
Build a cross-check table: activity, where it appears in the text, which budget line funds it, and whether the numbers match (participants, sessions, months, positions).
List separately: activities with no budget line, and budget lines with no explanation in the text. Don't suggest amounts.

Based on the full application: [paste], write a summary of up to [number] words.
One sentence for each of these: the problem, what we'll do, for whom, and what will change. Only what is written in the application.

One-page checklist

Before writing

• Folder with the full call, including appendices and questions and answers
• Organization card and verified data with source and year
• Past applications as samples
• Breakdown table: threshold conditions, criteria, structure, technical, with quotes
• A checked skeleton, and a list of questions for the team

While writing

• Section by section, in the call's order
• A length limit for every section
• No invented numbers, partners or results
• Every claim read and sourced

Checking

• Strict reviewer in a new conversation, a quote for every criterion
• Every requirement in the call answered
• Budget and text cross-check table, with no gaps
• Budget reviewed with the accountant

Before submitting (manual check)

• Every number, name, date and amount checked against the source
• No [to complete] left in the text
• Mandatory documents attached, valid and signed
• Format and length as instructed
• Every commitment approved and has an owner
• Submitted at least a day before the deadline
• A saved copy of what was submitted

How you know it's working

Before the next application, write down how long the previous one took, and measure against that:

• Time to a complete first draft: from the decision to apply to a draft that can be handed out for reading.
• [to complete] markers in the first draft: if the number drops from application to application, your organization card and data are filling up.
• Cross-check gaps: how many gaps between budget and text were found before submitting. The goal is to find them before the reviewer does.
• Technical rejections: how many applications were disqualified for a missing document, length or format. This number should be zero.
• Feedback from foundations: what the reviewers wrote, even when you won. Keep it next to the application.
• Win rate: measured over time, after several rounds. One application doesn't teach much.

Disclaimer

This content is general recommendations only, not professional, legal, accounting or tax advice. Every organization and every call for proposals is different. You are responsible for checking that it fits your situation, and for checking the data, prompts and text before submitting. Verify the eligibility rules and terms of every call with the funder. For budget, salaries, VAT and financial reporting, consult a certified accountant or tax adviser. Outside tools and terms of service change, so check them at the source.