I tried semi-automating proposal creation with Slack MCP and Claude Cowork

Hello. I'm Kodama from the Generative AI Integration Division of the AI Business Headquarters.
I usually work as a generative AI consultant, handling proposals and accompanying support (consulting) for customers on LLM and generative AI utilization, as well as PM duties.

Out of the blue — are you using AI to create proposals? And are you managing to create proposals in a way that feels "just right"?
Even though AI has made proposal creation easier, there's still a sense in the field that it doesn't quite work as expected, isn't there? (Like not being able to say what needs to be said)

How can we use AI to create proposals both "easily" and "just right"?
I believe the answer lies in 'context management'.

In fact, recently I've been piling project information into Slack, having Claude Cowork read it via Slack MCP, and assembling an operation that semi-automates everything from project organization to proposal slide creation — and it turns out to work remarkably well.

This article introduces the overall picture and an overview of each configuration.

Introduction (Prerequisites)

This article is structured in a way that can be directly useful for those who use 'Slack', 'Claude', and 'PowerPoint or Google Slides'.
That's because the proposal creation flow I've built uses the aforementioned resources.

However, the essential approach of "where to pull the 'context' from" should apply to many AI users.

Also, the word 'AI' used in this article does not refer to the broad definition, but specifically to 'generative AI and AI agents'.

I hope you'll read to the end.
With that said, this section summarizes "what we want to do" as an overview.

Having AI Create Proposal Slides

To begin with, creating a single proposal manually takes several hours. Before the advent of AI (LLM), it was normal for the entire process — from project organization to outline, structure, and slide creation — to take 3 to 5 hours when done by hand.

I believe the essential problem is not the time required itself, but rather "the fact that other work stops during that time".
Proposal creation is the type of work where you lose the context if you step away midway, so if you take a break by crossing a day boundary or handling another project, the switching cost is simply high.

In other words, you need to block out a solid chunk of time.

On the other hand, when you break down the proposal creation process, the points requiring human judgment come down to the following four:

• Defining what the customer's problems and challenges are
• What to propose in response to those challenges
• What will make the customer happy
• How much (cost) to charge

Conversely, processes such as turning the proposal outline into text, drafting the structure into slides, and formatting do not need to be done manually.
The approach here is to hand these tasks off to AI.

Leaving Context Management to AI

Another motivation is "context management".

As projects increase, information such as meeting minutes, customer statements, action items, and the history of pricing figures can no longer all fit in your head. Furthermore, the annoying point is that the cost of remembering "where did I write that again?" is surprisingly high — more so than the information itself.

In other words, even for a single task like creating a proposal, "cognitive load" gets in the way.

My countermeasure for this is to "place information where AI can read it, in a form that AI can read it".
By doing this, AI can take on the cognitive load itself, so in simple terms, humans can take it easy and multitasking becomes easier.

That's because even if the human forgets, they can just ask the AI "what was the status of this project again?"

What's Great About Linking Slack and Claude

As options for storing the context needed to create deliverables (information such as meeting minutes, customer statements, action items, and the history of pricing figures), there are also file servers, Notion, Google Drive, and others.

The reason I chose Slack is simple: project information is generated in Slack in the first place.
Meeting minute sharing, internal brainstorming, and exchanges with sales all happen in Slack. If you can leave information where it was generated, the task of transcribing information elsewhere disappears entirely — the idea being to turn Slack into a data lake.

This section breaks down those benefits (advantages) in an easy-to-understand way.

Reference (about data lakes)
https://dev.classmethod.jp/articles/aws-summit-online-2020-aws-03/

Context Management Becomes Easier

I create one thread per project and pile meeting minutes, received materials, and notes there in chronological order. What I'm doing here can't really be called "organizing" — it's more like stacking things from top to bottom as they come in. (See the attached image)

And by accumulating the full history of a project in this thread, the prerequisites for passing appropriate context to AI are being established.
By passing Claude just one thread URL, it reads the information via Slack MCP, and for humans too, it becomes sufficient to say "just check this thread for everything about this project".

This is precisely the state of "context management having become easier".

AI-Ready Information Organization Becomes Easier

One of the nice things about linking Slack and Claude is that "AI Ready" information organization becomes easier.

I define the term "AI Ready" here with the following three points:

• Accessibility: Being findable through search
• Quality: Raw information is preserved and can be appropriately referenced
• Dynamism: Information has a chronological order and changes can be appropriately tracked

Managing information in Slack threads makes it easy to satisfy these three points.
In my operation, I fix the opening message of a thread with the naming convention [Project Thread] Company Name Project Name. By doing this, you can easily search using the string "Project Thread" from both Slack search and from Claude.

Also, by consolidating information that is updated in the thread from time to time (business meetings, exchanges, and other items), raw information can be managed on a chronological basis. (See attached image)

Another tip is to keep the original text (raw data) of meeting minutes and customer emails without discarding them, while ensuring that the information the LLM reads first is in a "data-formatted" state.

Raw information is important primary data, but it often contains unnecessary context, and passing it directly to an LLM can lead to hallucinations and unexpected outputs. (Data noise from unstructured data)

However, when you want to check the history of pricing or the fine nuances of statements, you also want to reference the raw information itself. To address this dilemma, I take the approach of "placing the formatted data for the LLM to read and the original text for verification side by side in the same thread".

This will be explained later in 'Slack Thread Operation as Context', so please refer there for details.

Reflecting Stakeholder Feedback Becomes Easier

The third benefit is that the ease of incorporating feedback improves dramatically.
In the process leading up to creating a proposal, you likely have opportunities to speak with project stakeholders such as the sales representative and members scheduled to attend or be assigned. (Such as requirements organization and pricing consultations)

Ideally, you'd want to capture those conversations as information too.
In such cases, when stakeholders converse within the thread I operate, information on the outline and pricing is left there as information in place, becoming one of the contexts to pass to the AI agent.

From an example I actually experienced — for a certain project, I posted an outline v0 to the thread and asked a sales member for a review, and received the feedback: "It's unexpected that the description says our company will handle the initial setup, so please remove it."
This feedback remains as an exchange on the thread just as it is.

This review exchange itself becomes the next context, and by instructing Claude to "reflect the review comments in the thread," the effort of rewriting the feedback as correction instructions is eliminated.

Basic Architecture for a Proposal Slide AI

Now, from this section onward, I'd like to give an overview of the basic architecture (design) needed to actually have the AI agent create proposal slides.

Since this is a part where we break down "what it means to have AI create a proposal," if you want to quickly find out the specific configuration steps, please refer to 'Preparing Slack MCP (Connector)' and beyond.

All You Need Is 'Proposal Structure' and 'Slide Creation Capability'

I think a proposal AI can be broken down into the following multiplication:

Proposal AI = Proposal Structure (what to say) × Slide Creation Capability (how to present it)

In other words, the former is determined by the quality of the context, and the latter is determined by the refinement of templates and creation procedures.
Since the capabilities required for these two are completely different, they need to be designed separately.

Some of you may have tried "creating slides with AI" and gotten mediocre results, but I suspect the cause in most cases is underestimating the former — the context.

That's because if you output only polished slides without sufficient context, you end up with a proposal that has no substance.

What Context Is Needed to Build the Proposal Structure

Next, let me try to organize what is needed for the proposal structure.
In my experience, I believe having the following four-part set in place is what allows a basic proposal structure to come together.

I believe that if these four items are in place, a minimum viable outline can be written.

And where does the specific content of these four items typically come from?

• Meeting minutes from the first meeting
• Answers from hearings
• Internal pricing brainstorming

In other words, (in my case) all of this is information managed in Slack threads.

An Environment to Instruct Claude on 'Appropriate READ and WRITE'

Once the context is in order, the next step is to create an environment that instructs Claude on "what to read, in what order, and what to write where and how".

The key to designing the READ side is to fix the reading order.

In my Claude Cowork project 'Document Creation Project', I have it read in the following order:

1. Customer information (company.md)
2. Project overview (overview.md)
3. Related materials linked to the project (meeting minutes, received materials)
4. Proposal structure (proposals.md)
5. Slide template

The reading order is prepared in the sequence of customer understanding → project understanding → detailed ToDo → expression rules, so that the AI agent doesn't need to accumulate unnecessary context.

For the WRITE side, I place importance on making rules explicit.

• Directory conventions (fixing the folder structure per customer and project)
• File naming (YYYYMMDD_document-name_vN.pptx)
• An operational rule to increment the version rather than deleting old files
• Visual requirements (template compliance, font size, text tone, etc.)

Also, regarding template work, by turning it into Skills, script execution in the background stabilizes the output, so it's a good idea to create Skills with your preferred requirements.

To summarize: don't let it create too freely — have it create within the rules. But let the LLM determine the policy for writing the content itself.

Slack Thread Operation as Context

As mentioned earlier, on the Slack side, while it's important to store raw data, it's also necessary to format the data so that AI can read it easily.
(Previously mentioned: What's Great About Linking Slack and Claude > AI-Ready Information Organization Becomes Easier)

For example, from the perspective of "meeting minutes," suppose you want to use a voice transcription file from an online business meeting as context. The transcription file is raw data, but its accuracy is heavily dependent on speaker diarization performance and the speaker's own articulation.

In addition, the transcription output itself cannot be called structured data.
As meeting minutes, you'd at minimum want a summary of 'the purpose of the conversation', 'the goal of the conversation', 'what was discussed', and 'what to do next'.

So, to have data in a form that AI can easily read, I think the following two approaches are effective:

• Using online meeting minute AI such as Gemini or Zoom AI Companion
• Creating your own prompts or skills for summarizing transcriptions

In my case, for meeting minutes I use the former meeting minute AI, and I paste the pre-summarized conversation as a markdown file into the Slack thread.

Preparing Slack MCP (Connector)

Here are the configuration steps. First, let's create the connection with Slack. Claude has a Slack connector (MCP) available, so this can be completed with just screen operations.

1. Select the Connector from the Settings Screen

First, open Claude's settings screen and select "Connectors".

2. Search for Slack

Next, search for "Slack" on the connector list/search screen.
Click the "Connect/Link" button on the snippet that appears in the search results.

The next screen will show you a screen to continue the connection, so proceed to the next step.

3. Connect and Complete OAuth Authentication

Next, you will be redirected to the Slack OAuth authentication screen.

On the authentication screen, confirm the workspace you are connecting to and allow authentication.
Just to be safe, make sure to check the app permissions being granted at this point.

There are two supplementary notes.

• In managed workspaces such as Enterprise, you may not be able to connect unless the Slack administrator has pre-approved the app. In that case, you'll need to request approval from the Slack administrator.
• Authentication is per Slack account. The scope that Claude can read is the same as what the authenticated user can read on Slack — it does not extend beyond that.

Preparing Claude Cowork

Next is the Claude Cowork side. Here, three elements need to be prepared.

Set Up the Proposal Creation Project

First, create a project for proposal creation and decide where to store the materials. My project folder structure is as follows:

.（project root）
├── document-templates/
├── customer-name-A/
│   ├── company.md      # Company overview, key persons, business flow, project history
│   ├── project-name-A/
│   │   ├── overview.md # Project overview, scope, schedule, document list
│   │   ├── ToDo.md
│   │   ├── 00_docx/
│   │   ├── 01_pptx/
│   │   ├── 02_xlsx/
│   │   ├── 03_pdf/
│   │   └── 04_img/
│   │   └── proposals.md
│   └── project-name-B/
└── customer-name-B/

A key configuration point is that customer-level information (company.md) and project-level information (overview.md) are separated.
By doing this, customer understanding can be reused for second and subsequent projects with the same customer.

Configure the Procedure (CLAUDE.md)

Next, write the procedures and conventions that Claude should follow in the project's instruction file.
※ There are opinions lately that CLAUDE.md isn't that effective, but let's go with the classic approach for now...

The following is an excerpt of what I actually write:

## Basic Principles

- Before starting any work related to a customer or project, always read the
  company.md of the target customer and the overview.md of the target project.
- When creating documents, always reference the appropriate template
  from under the document-templates/ directory.

## When Requested to Create Proposal Materials
1. Read in order: company.md → overview.md → related materials → template.
2. First present a structural proposal (at the agenda level) to the user,
   and proceed to full creation only after obtaining agreement.
3. Conduct a self-review after creation.
   - Content consistency review (check for inconsistencies in pricing, dates, proper nouns, and scope)
   - Winning strategy review (cross-check against the checklist in the project organization md)
   - Expression review (detection and correction of AI-sounding expressions)

## Prohibited Actions
- Do not delete or overwrite existing files without explicit confirmation from the user.
- Do not reuse one customer's information in another customer's materials.

I think there are two key design points.

The first is that a step where a human agrees is built in at the structural proposal stage. This is because correcting the structure after the slides are complete involves significant rework, so I want to lock in the agenda level first.

The second is that the self-review is explicitly written as a step in the process.
Since I want to stabilize the quality of feedback, I document the review perspectives and place them in the project.

Creating the Slide Creation Skill

The last step is the slide creation skill. This is the process of consolidating the requirements for "how to visually present" things.

• Layout specifications compliant with the slide template
• Minimum font size
  • AI-created slides tend to have small text
  • I include an instruction to enlarge text 1.2 to 1.5 times after generation
• Text tone specification
  • Since the words AI outputs can feel subtly off, I specify the tone

Within the tone specification, what I personally find works well is the automated checking for AI-sounding expressions.
I maintain a list of NG words that tend to appear in proposals, and have them checked with grep after generation.

The following is a partial excerpt:

"を実現します" (will realize), "シームレス" (seamless), "〜への第一歩" (first step toward ~), "価値を最大化" (maximize value)
→ Do not use

Having AI Create a Proposal from a Slack Project Thread

Up to this point, the preparations for the Slack side (the repository for primary information) and the Claude Cowork side (the rules and workspace) are in place.
In this section, I'll introduce the flow from actually connecting these two to having a proposal created, in the order I normally follow.

To give you the full picture upfront, there are four steps:

1. Have it read the project thread and create overview.md
2. Transfer attached files from the thread to the project
3. Request proposal creation
4. Have it reflect review comments from the thread

The key point is that rather than having it read the Slack thread directly each time, I first incorporate it into overview.md and then have it create the proposal.
The role division is: Slack is "the place where generated information is piled up as-is," and overview.md is "the place where that information is organized for the proposal."

1. Have It Read the Project Thread and Create overview.md

First, open the 'Document Creation Project' folder in Claude Cowork, pass the project thread URL, and request project organization.
The prompt I actually send is essentially the following single sentence, and I write nothing more than this:

Please read this Slack thread and create customer-name-A/project-name-A/overview.md.
https://xxxxx.slack.com/archives/CXXXXXXXX/pXXXXXXXXXXXXXXXX

Claude will then read the thread from top to bottom via Slack MCP, extract information corresponding to the aforementioned four-part set (challenges & background / support & service content / schedule & structure / unit price & estimate units), and write it out to overview.md. (See attached image)

What's "great" here is that even if the pricing in the thread changed multiple times, it picks up the entire history along with the context.
A flow like "initially presented at ○○ million → sales asked to bring it down to ○○ million → finally agreed at ○○ million" is preserved in overview.md chronologically as-is. The effort of the human thinking "wait, what price did we end up going with?" is eliminated.

Note that from the second time onward, you can just say "re-read the thread and update overview.md" and only the differences will be reflected.
Since CLAUDE.md prohibits unauthorized overwriting of existing files, it will be appended in a form that retains the update history.

(The following is what this step looks like when translated into CLAUDE.md:)

## When Requested to Import a Project Thread
1. Read the passed Slack thread URL with the Slack connector and
   extract challenges & background / support content / schedule & structure / pricing history.
2. Reflect in the target project's overview.md.
   Do not overwrite existing entries; manage with appended additions and update history.
3. Points where judgment is divided (pricing, scope) should be
   explicitly marked as "undecided" and not arbitrarily confirmed.

2. Transfer Attached Files from the Thread to the Project

Next, transfer the meeting minute mds and received materials posted in the thread to the project side.
This too is just a matter of saying "save the attached files in the thread, organized by type into 00_docx/, 03_pdf/, etc., and append them to the document list in overview.md."

Here, let me write the answer to the dilemma mentioned earlier in 'AI-Ready Information Organization Becomes Easier' — "I want to keep the raw information, but I don't want to pass it directly to the LLM."

In my operation, I post both the summary md output by the meeting minute AI and the original transcription file to the Slack thread.
And I instruct Claude to use the summary md as the starting point when creating proposals, and to refer to the transcription only when checking pricing statements or fine nuances.

In other words, by placing "formatted data for reading" and "original text for verification" side by side in the same thread, the intention is to have it both ways — suppressing context noise while not discarding primary information.

3. Request Proposal Creation

Once the materials are ready, it's time for the proposal.
The request is also simple — something along the following lines:

Please create a proposal for customer-name-A/project-name-A.
Please use document-templates/proposal_standard.pptx as the template.

From here, the procedure written in CLAUDE.md kicks in.

1. Read in order: company.md → overview.md → related materials → template
2. A structural proposal (at the agenda level) is presented
3. The human checks and confirms, then agrees
4. The slide creation skill runs and generates the pptx
5. The self-review results (content consistency, winning strategy, expressions) are returned

The actual structural proposals returned are at the following level of granularity. (See attached image)

At the structural proposal stage, the only two things I check are: "whether the way the customer's challenges are described matches the statements in the thread" and "whether items out of scope are clearly stated."
As long as these are confirmed, even if the slide content is somewhat off, it can be fixed later. Conversely, if these are misaligned and you proceed, you'll end up redoing every page.

After agreement, 01_pptx/YYYYMMDD_proposal_v1.pptx is generated in a few minutes. (See attached image)

The self-review results are returned at the same time, so checks like "does the pricing match overview.md?" and "are there any NG words remaining?" are already completed by Claude before I even look at them.

4. Have It Reflect Review Comments from the Thread

Finally, reflecting the review.
Post the generated v1 to the Slack project thread and ask sales and attendee members for a review.

Have them write their feedback directly in the thread. Feedback like the previously mentioned "It's unexpected that the description says our company will handle the initial setup, so please remove it."
At this point, I don't rewrite the feedback into correction instructions at all — I simply ask Claude as follows:

Please read the review comments posted after v1 was shared in the project thread,
and create a v2 that reflects the feedback. Please also output a list of what was reflected.

Claude reads the relevant section of the thread and outputs v2.pptx along with a list of "which slide, which text, and how it was changed" for each piece of feedback. (See attached image)

At this point, if the feedback includes anything related to the project's premises — such as "remove something from scope" — I also have it reflected in overview.md.
By doing this, when the same customer's next project comes around, even where things were debated last time remains as context.

This completes one cycle.
The only things the human is doing are: posting the URL in step 1, agreeing to the structural proposal in step 3, and requesting the review in step 4 — just these three.

When Slack and Claude Integration Doesn't Work Well

Finally, let me write some troubleshooting for when the Slack and Claude integration isn't working well.
I hope you'll find it useful.

Disconnect and Reconnect the Connector

If Slack MCP isn't working properly (can't call the API, errors appearing), you can assume in most cases that it's due to authentication token expiration.

In such cases, disconnecting the Slack connector from the settings screen and reconnecting usually fixes it.
It's like the kind of thing that gets fixed when you restart it.

Check Administrator Permissions for Slack or Claude

If Slack doesn't appear in the connector list at all, or if you're rejected midway through OAuth authentication — in this case, individual settings alone won't resolve it; you'll need to check the administrator settings.

• Slack side: Check whether the Claude app is approved in the workspace's app approval policy
  • If not approved, request approval from the Slack administrator
• Claude side: In Team and Enterprise plans, the organization's administrator can control connector availability
  • If it's disabled in the admin panel, request it from the organization administrator.

Configure Tool Permissions for the Connector

If the connection is working but only search works while posting doesn't —

Connectors have permission settings per tool (search, channel reading, message sending, etc.). After connecting, check these settings and verify that the necessary tools are enabled.

Summary

Up to this point, I have introduced an operation that uses Slack project threads as the repository for primary information, has Claude Cowork read them via Slack MCP, and creates proposals within a project with written rules.

This operation started with the intention of leaving humans with only approval and review processes, and I intend to continue using and upgrading it going forward.
I hope it will be helpful for those who, like me, are getting their time locked up by pre-sales proposal creation.