Six Problems, One Folder: A Local-First Playbook for Office AI

Six problems from one company

A friend who runs a company sent me a two-page document last week, titled How Using AI to Boost Workplace Productivity. It listed six numbered problems, written the way an operator writes: no theory, just the places where the tools keep falling short of the workday.

1. Slide decks that look professional: coherent storyline, consistent images, layouts that don't scream "generated," language that doesn't sound like AI.
2. A project workflow where one meeting recording becomes six documents, internal update, external email, action tracker, risk register, decision log, timeline, without re-prompting from zero every time.
3. Prompting that makes the model behave like a researcher or consultant instead of a summarizer: case analysis, international benchmarks, root-cause work, strategy assessment, critical review.
4. Knowing when to trust what the AI says, especially on policy, regulation, semiconductors, investment figures, and research data.
5. A rigorous research workflow: literature review, gap analysis, research questions, hypothesis generation, framework synthesis, case comparison.
6. AI across the full lifecycle of an academic paper, and the uncomfortable question underneath it: how will the university detect and evaluate this, and where exactly is the line?

Six problems, four tools on the table: ChatGPT, Codex, Claude, and Claude Code. And one principle that runs through every answer below: work locally first. Keep the source material, the drafts, the sources, and the outputs as files in folders on your own disk, and put an agent inside those folders. The chat window is where you think out loud. The folder is where the work lives.

TL;DR

- Two subscriptions cover everything here: ChatGPT Plus at $20 and Claude Pro at $20, upgrading to the $100 tiers only when you hit limits. Both plans include a full local agent, Codex and Claude Code, at no extra cost. - Slides: separate storyline, layout, and imagery into three jobs. Write the storyline as a file, render the deck from a fixed template with an agent, generate images once against a saved style sheet. - Meetings: one skill file turns any transcript into all six documents, appending to living trackers instead of regenerating them. - Consultant-grade output comes from giving the model the whole case file and a grading rubric, then having the other vendor's model attack the result. - Trust: no number enters a document without a URL, sources get saved to disk, and two models cross-examine each other. Frontier models still hallucinate at 3 to 19 percent depending on task [4]. - Academic integrity: detection doesn't work and OpenAI retired its own detector [6]. The defensible line is a process log plus disclosure, which a local-first setup produces automatically.

The roster

The two bolded rows are the ones most offices haven't opened. Both are agents that run on your machine, read and write your files, execute programs, and search the web. Both read a standing instruction file at the root of whatever folder they work in: CLAUDE.md for Claude Code, AGENTS.md for Codex [3]. Write your rules once in one of them, then tell either agent to copy it to the other name. From that moment both agents know your filing conventions, your house style, and your templates before you type a word.

If the phrase "local agent" is new, my previous post covers the foundation in detail: the folder structure, the instruction files, installation, and local meeting transcription (The Claude Power User Field Manual). This post assumes that base and assigns tools to problems.

The hardware this needs

None of the above needs a powerful machine. Claude Code and Codex send your files up to the model and get text back; the heavy computation happens on Anthropic's or OpenAI's servers, not yours. The one local job with real hardware weight is Whisper transcription in Problem 2, and even that runs on a laptop.

The laptop you already own, if it's from the last six years:

If your laptop runs a modern browser without struggling, it runs everything in this post except heavy Whisper transcription.

Buying new, for someone who wants headroom: 16 GB RAM, any recent CPU, an SSD with at least 50 GB free if Cowork will index a full project folder [12]. That's roughly a mid-range laptop at any price point in 2026, nothing marketed as a "workstation" or "gaming" machine required.

The home-server tier, for the NextCloud-plus-Tailscale setup in Problem 2 and the field manual: a mini PC is the right hardware, not a tower. Three tiers, current prices [14]:

A Mac mini M4 (from $599, 16 GB RAM) works too and runs whisper.cpp well on its own chip, at a higher price than the Beelink tiers for the same job [15]. None of these needs a graphics card; transcription and file serving are not GPU-bound workloads at this scale.

The one place a GPU matters: running the largest Whisper model (large-v3) at speed. On CPU alone it takes about ten minutes to transcribe a one-hour meeting with the small model, and around three hours with large-v3 [16]. Most offices never need large-v3; small or medium transcribes clearly-recorded meetings well and finishes in minutes on any machine in the tables above. Reach for a GPU only if you're transcribing hours of audio daily and the CPU wait becomes the bottleneck, not before.

Problem 1: Slide decks that don't look generated

The document's pain points were specific: no storyline structure, images inconsistent across slides, amateur layout, language too obviously machine-written. Each pain comes from asking one chat window to do three different jobs at once. Separate them.

Storyline is a thinking job. Do it in Claude chat, and save the result as a file, because the deck will be rebuilt four times before the board sees it. The structure consultants have used for fifty years is Barbara Minto's pyramid: answer first, then the two to four arguments that support it, then the evidence under each [7]. Ask for exactly that:

Here is my raw material [paste or attach]. Build a Minto pyramid for a 12-slide deck to [audience] whose one-line answer is [the decision you want]. Give me: the governing thought, three key-line arguments, and the evidence each slide must show. Output as outline.md with one section per slide: headline sentence, supporting points, and what the visual should prove.

The output goes into your project folder as outline.md. That file, not the chat, is now the source of truth.

Layout is a rendering job, so never let a chat tool freestyle it. Rendered decks from a fixed template are consistent by construction. Claude Code does this well with Marp, an open-source tool that turns Markdown into slides through a CSS theme [8], or with python-pptx when the deliverable must be genuine PowerPoint in the corporate template. You don't install anything yourself. Open Claude Code in the project folder and say:

Read outline.md. Build a slide deck from it using Marp. Create a theme file at resources/brand/theme.css with [your colors, your font], 24pt minimum body text, one idea per slide. Render to PDF and to editable source. If Marp isn't installed, install it.

Every future deck uses the same theme file, so consistency comes from the pipeline instead of whoever built the last deck.

Images are an asset job. The inconsistency problem comes from generating each image in a fresh chat with a fresh style. Instead, spend twenty minutes in ChatGPT once: generate a style sheet, meaning three or four reference images that define your visual language, and save them to resources/brand/images/. Every later request attaches one and says "same style, same palette, same level of detail, new subject." Reference-image conditioning is the single biggest lever for cross-slide consistency, and the saved folder means the style survives across months and across tools.

Language: fix the "AI-sounding" problem in the instruction file, not per prompt. A CLAUDE.md house-style section bans the tell-tale words and rhythms of machine prose and applies to every deck, every email, every document. Mine bans em-dash chains, contrast-payoff sentences, and about thirty words. Slide text drafted under those standing rules sounds like the person whose name is on the title slide, not a template.

Problem 2: One meeting, six documents, zero re-prompting

The document sketched the dream pipeline: meeting ends, and the minutes become an internal update, an external email, an action tracker, a risk register, a decision log, and a timeline. Today that requires re-prompting from scratch every time, because the instructions live in someone's head and the outputs live in a chat history.

Move both into the folder. The transcript arrives locally (recording dropped into inbox/recordings/, transcribed on your own machine by Whisper, no upload, as covered in the field manual). Then one skill file defines the whole fan-out. A skill is a folder with a plain-language instruction file that either agent loads on demand [5]; here is the load-bearing excerpt of mine:

# /process-meeting

Given a transcript in inbox/recordings/:
<ol>
<li>Identify the project it belongs to from projects/. Ask if unclear.</li>
<li>Produce per-meeting files in that project folder, dated:</li>
</ol>
   - internal-update.md  (one page, decisions first, then asks)
   - external-email.md   (client-safe: no internal costs, no names
     of undecided options, formal register)
<ol>
<li>APPEND to the project's living files, never regenerate them:</li>
</ol>
   - action-tracker.md   (table: action, owner, due, status)
   - risk-register.md    (add new risks; update likelihood of old)
   - decision-log.md     (decision, date, who, alternatives rejected)
   - timeline.md         (shift dates only with an explicit note)
<ol>
<li>Flag any new decision that contradicts an earlier entry</li>
</ol>
   in decision-log.md, with both dates.

The update and the email are per-meeting documents, but the tracker, register, log, and timeline are living files that accumulate. Regenerate them from each meeting and you lose history. Append instead, and the decision log turns into the most valuable file in the company: step 4 catches the Tuesday decision that quietly reverses March's, which no human rereading four months of minutes would.

After the setup, the entire workflow is one line, spoken to Claude Code or Codex in the work folder:

Process this morning's recording with /process-meeting.

Problem 3: Analyst, not summarizer

The complaint here is universal and the diagnosis is almost always wrong. People blame their prompt wording. The real difference between a summarizer and an analyst is that an analyst has the case file, a deliverable spec, and someone who will check the work. Give the model all three.

Start from the case file, not a paste. A web chat sees only what you paste in. An agent in your project folder reads the contracts, the financials, the meeting notes, and the prior reports, then cross-references them. Root-cause analysis on a paste is guesswork; root-cause analysis on the folder is investigation:

Read everything in projects/2026-factory-delay/. Perform a root cause analysis of the delivery slippage: build a timeline of events from the meeting notes, identify where the plan and the reality first diverged, and trace each candidate cause to evidence in specific files. Distinguish causes from symptoms. Cite file names and dates for every claim. Rate your confidence in each cause and say what missing document would raise it.

The deliverable spec and rubric turn a role-play into an engagement. "Act as a consultant" produces consulting-flavored text. What works is naming the deliverable and the standard it will be graded against: "Produce a strategy assessment structured as situation, complication, options with a weighted scoring table, recommendation, and risks of the recommendation. I will grade it on whether each option's score is traceable to a cited fact, whether the strongest case against the recommendation is stated fairly, and whether an experienced operator would find any claim unsupported." Models rise or sink to the rubric they're given.

For benchmarks, use ChatGPT's Deep Research, which spends ten to thirty minutes reading dozens of sources and returns a cited report. It's the right tool for "how do Korea, Taiwan, and Vietnam structure semiconductor investment incentives" style questions. Then apply the next section to its citations, because a cited report and a correct report are different things.

The checker is the other vendor's model. This is the cheapest quality upgrade available in 2026 and almost nobody uses it: you're already paying for two frontier labs. When Claude produces the strategy assessment, hand it to Codex:

Here is an analysis produced by another AI. You are the skeptical partner reviewing it before it goes to the client. Attack it: find unsupported claims, arithmetic errors, benchmarks that don't say what the text claims, and the strongest counter-argument to its recommendation. Verify three of its citations by fetching them.

Different labs, different training data, different blind spots. Where they agree you gain confidence; where they disagree you've found exactly the paragraph that needed a human.

Problem 4: Trust, sources, and the hallucination question

The document named the hard domains: policy, regulation, semiconductors, investment, research figures. Correctly so. These are exactly where models are most fluent and least reliable, and the 2026 numbers say the problem is better but not gone: measured hallucination rates on frontier models run from roughly 3 percent on grounded summarization to 19 percent on open-ended factual tasks, depending on model and configuration [4]. Three rules make the difference between managed risk and quiet catastrophe.

Rule one: model memory is a rumor. An answer produced without live search is the model's recollection of its training data, which has a cutoff and no accountability. For anything with a date, a number, or a legal consequence, require search and require links: "Search for this; every figure needs a source URL; if you cannot find a source, say so instead of answering." Both Codex and Claude Code ship with web search built in [3]. A model that's told "no source, no claim" mostly complies. A model that isn't told fills silence with fluency.

Rule two: sources are files, so save them. The local-first move that changes verification from a vibe into a procedure: make the agent keep what it read.

For the report in draft.md: fetch every cited source, save each to sources/ as a text file named by claim number, then produce claims-audit.md: a table of every factual claim, its source file, the exact supporting quote, and a verdict of SUPPORTED, PARTIAL, or NOT FOUND. Do not soften NOT FOUND.

Now the audit is on your disk. Six months later, when someone challenges a number in the report, you have the source as it existed the day you cited it.

Rule three: rank the source, not the sentence. The model presents a ministry circular and a Medium post with identical confidence. The hierarchy has to come from you, and it belongs in your instruction file so it applies forever:

And for anything that will be signed, spoken, or filed: the two-model cross-examination from Problem 3, then human eyes on every Tier 1 source the models disagreed about. The models do the reading; the judgment stays yours.

Problem 5: Research that would survive a methods review

The wish list was literature review, gap analysis, research questions, hypothesis generation, framework synthesis, and case comparison. The rigorous version of all six rests on one artifact: a literature matrix built from full texts, on your disk.

The pipeline: ChatGPT Deep Research finds the field ("map the literature on X since 2022: seminal papers, main camps, recent survey articles"), you download the twenty to forty PDFs that matter into research/papers/, and the local agent reads all of them completely and builds the matrix. A chat tool working from pasted excerpts cannot do this; an agent with the folder open can:

Read every PDF in research/papers/. Build literature-matrix.md: one row per paper with author-year, research question, method, sample or dataset, key findings with the numbers, stated limitations, and the page number for each finding. Then write gaps.md: questions no paper answers, populations or contexts no paper covers, contradictions between papers with both citations, and methods that haven't been applied to this problem.

Gap analysis stops being a matter of opinion here: the gaps are empty columns and contradicting rows in a table you can check. Research questions come from the gaps; each candidate hypothesis then gets the adversarial treatment before you invest a month in it:

For hypothesis H: argue the strongest case that it's false or unfalsifiable. Which papers in the matrix cut against it? What result pattern would disconfirm it? What would the study need to measure to distinguish H from the boring alternative explanation?

Framework synthesis and case comparison are the same move at higher altitude: "build a comparison table of how papers A, D, and F would each explain phenomenon P, then propose a framework that subsumes them, stating what each source framework contributes and what your synthesis predicts that none of them does."

Two disciplines keep this honest. Every quote carries a page number, and you spot-check quotes against the PDFs before anything ships, because a fabricated quotation in a literature review is career damage no workflow can undo. The matrix makes spot-checking a five-minute job instead of an afternoon.

Problem 6: The line, and how a university sees it

The document's final question was the bravest one: if AI runs through the whole lifecycle of a paper, how does the institution detect and evaluate that, and how do you draw a clean line?

Start with the uncomfortable empirical fact: detection doesn't work. OpenAI shut down its own AI-text classifier in 2023 for low accuracy; it caught about a quarter of AI-written text while false-flagging human writing [6]. Worse, Stanford researchers showed detectors misclassify essays by non-native English speakers as AI-generated at rates above 60 percent, while near-perfectly passing the same ideas polished by a model [9]. A Vietnamese researcher writing in English is precisely the person these tools wrongly accuse. Any integrity strategy built on detection is built on sand, and the serious institutions know it.

What the serious institutions did instead is draw the line at authorship and disclosure. Nature and the ICMJE set the standard in 2023 and it has held: an AI cannot be an author because it cannot take responsibility for the work, and any substantive use must be disclosed in the methods or acknowledgements [10]. That gives you a workable test for every task in the lifecycle:

The personal version of the test is simpler: if your committee asks about any sentence in the paper and you can defend it, its evidence, and its place in the argument without the tool in the room, the work is yours. If you can't, no disclosure statement fixes that.

A local-first setup produces the defense as a side effect. An agent working in a git-tracked folder, with a hook that logs each session's actions to worklog.md, keeps a timestamped record of the whole process: when the matrix was built, which drafts you rewrote and how much, what was verified when. A chat history is a vendor's database entry. A process log on your disk is evidence, the same way a lab notebook is. Disclosure norms will tighten further, and the people with nothing to fear will be the ones whose workflow was auditable all along.

What to buy, and what it replaces

Forty dollars a month, two agents, one folder. Everything in this post runs on that. The $100 tiers exist for the week the meeting load or the research sprint outruns the limits [1][2]; you'll know that week when it arrives.

The document listed six problems, but the same root cause runs under all of them: work trapped in chat windows, owned by vendors, structured by nobody. Files, folders, standing instructions, and two agents that can read them fix all six at once. Set it up in the order written here; each section makes the next one shorter. If you'd rather hand the setup to someone who has built it before, my inbox is open.

---

References

1. OpenAI. ChatGPT pricing and Codex plan inclusion. openai.com/chatgpt/pricing and help.openai.com, 2026. Plus $20/mo; Pro tiers from $100/mo introduced April 2026; Codex usage included in paid plans with credits as pay-as-you-go overflow.
2. Anthropic. Claude plans. claude.com/pricing, 2026. Pro $20/mo ($17 annual); Max 5x $100/mo; Max 20x $200/mo; Claude Code included in all paid plans.
3. OpenAI. Codex CLI documentation and changelog. developers.openai.com/codex, 2026. AGENTS.md instruction files; web search enabled by default for local tasks since January 2026; open-source CLI.
4. "AI Model Hallucination Rate Benchmarks 2026: 5-Model Study." digitalapplied.com, 2026. Frontier-model hallucination rates of 3.1 to 19.1 percent across task families; grounded-summarization leaderboard rates of roughly 3 to 8 percent.
5. Anthropic. "Agent Skills." Claude Code documentation, code.claude.com/docs, 2026. SKILL.md structure and on-demand loading of named routines.
6. OpenAI. "New AI classifier for indicating AI-written text." openai.com/blog, 2023 (tool retired July 2023). Sensitivity of 26 percent on AI text; 9 percent false-positive rate on human text; discontinued for low accuracy.
7. Minto, B. The Pyramid Principle: Logic in Writing and Thinking. Financial Times/Prentice Hall, 2009 edition. Governing thought, key line, and evidence layers for executive communication.
8. Marp (Markdown Presentation Ecosystem). marp.app, 2026. Markdown-to-slides rendering with CSS themes. python-pptx: python-pptx.readthedocs.io, for template-bound PowerPoint generation.
9. Liang, W., Yuksekgonul, M., Mao, Y., Wu, E., Zou, J. "GPT detectors are biased against non-native English writers." Patterns 4(7), 2023. arXiv:2304.02819. Detectors flagged over 61 percent of TOEFL essays by non-native speakers as AI-generated.
10. Nature editorial. "Tools such as ChatGPT threaten transparent science; here are our ground rules for their use." Nature 613, 612, 2023. No LLM as credited author; use documented in methods or acknowledgements. Consistent with ICMJE recommendations.
11. Anthropic. "Set up Claude Code." code.claude.com/docs/en/setup, 2026. Official system requirements: 4 GB RAM, x64 or ARM64, macOS 13+/Windows 10 1809+/Ubuntu 20.04+/Debian 10+, internet required.
12. Houtini. "Claude Code System Requirements: Mac, Windows, Linux (2026)" and "Claude Desktop System Requirements" (2026-06-06). Practical RAM/disk guidance beyond the official minimum, including Cowork's full-workspace indexing needs.
13. Zilliz. "What are Claude Code system requirements?" zilliz.com/ai-faq, 2026. CLI disk footprint under 500 MB.
14. Mini PC Lab. "Best Mini PC for Nextcloud 2026." minipclab.com, May 2026. Beelink EQ14, GEEKOM IT12, and Beelink SER9 pricing, RAM, and idle power draw for home NextCloud hosting.
15. Apple. Mac mini pricing, apple.com/mac-mini, 2026. M4 configuration starting at $599 with 16 GB RAM.
16. StarWhisper. "Whisper.cpp GUI for Windows: CUDA + Vulkan + CPU." starwhisper.ai, 2026; SYSTRAN. "faster-whisper" benchmarks, GitHub, 2026. Per-model transcription time and RAM by hardware tier, tiny through large-v3.

Prices and tool facts verified against vendor pages and current reporting, July 2026.

Last updated: July 6, 2026