How I AI: JJ Englert's Guide to a 'Daily Operating System' with Claude Cowork

JJ Englert’s version of Claude Cowork is less a chatbot and more a lightweight operating system for knowledge work. In this episode of How I AI, he builds a setup that remembers how he works, drafts in his voice, reviews work from multiple perspectives, and prepares him for the day before he opens Slack.

I was skeptical when Cowork launched. At first it felt like a friendlier shell around Claude Code without a clear audience in between developers and casual chat users. JJ’s walkthrough changed my view because it showed how a non-terminal workflow can steadily accumulate context, permissions, and reusable skills until the tool starts acting more like an operational layer than a chat window.

The setup has four connected layers: a persistent project folder, an email-writing skill trained on sent messages, a panel of simulated reviewers, and a scheduled morning briefing. The important detail is that each layer inherits the context established before it. JJ is not rebuilding prompts from scratch every time. He is creating an environment where Cowork remembers the files, instructions, collaborators, and workflows attached to a specific project.

Start with a persistent project instead of isolated chats

JJ starts with a local folder connected to a Cowork project. That sounds almost too simple, but it is the core architectural decision in the whole workflow. Instead of scattering instructions across random chat threads, the folder becomes the stable home for files, prompts, skills, and project memory.

Create a dedicated workspace folder

JJ creates a folder called Daily Operating System and treats it as the headquarters for recurring work. In Cowork, a project is essentially a folder on your computer plus the shared memory attached to it. Once Claude can access that folder, future chats inside the project inherit the same context automatically. You can follow the full implementation in How to Set Up a 'Daily Operating System' in Claude Cowork. See How to Set Up a 'Daily Operating System' in Claude Cowork.

"This is the start of everything, and then it's an empty folder. Now I'm gonna go back into Cowork here, and I'm going to load up this folder." - JJ Englert

Build a reusable brain file

Inside the folder, JJ keeps a markdown file he calls his brain. It contains working preferences, communication patterns, collaborator context, recurring instructions, and guidance on how he likes feedback delivered. The point is not to create a giant autobiographical dump. It is operational context that helps Claude ramp up quickly without repeating setup instructions every session.

He also uses supporting files like workspace maps that explain the folder structure itself. Claude can generate these automatically by scanning the project directory. That matters once projects become large because Cowork does better when it knows where relevant information lives instead of ingesting every file every time.

"My brain goes into very detail of like, what are my working preferences? Who are the team members that I work with? ... This is a very specific series of instructions that we, you know, also known as a prompt that Claude can read to get up to speed very quickly of who you are, how you like to work." - JJ Englert

Attach the folder to a Cowork project

In Claude Desktop, JJ creates a Cowork project from the existing folder and gives it a short instruction set describing the role of the system. His framing is intentionally broad: help navigate the day-to-day life of a busy professional, assist with communication, and provide support for decision-making.

One subtle but important distinction in this episode of How I AI is the difference between tasks and projects. Tasks are individual work sessions. Projects are persistent environments with shared memory across tasks. Once chats move into a project, Cowork starts carrying context forward automatically instead of treating every interaction like a blank slate.

I'm gonna use this folder and operating system to help me navigate the day-to-day life of a busy professional. You're gonna help me with some superpowers by applying some AI magic to it all.

That shared memory becomes the real unlock. Skills, scheduled tasks, and future conversations can all reference the same files, instructions, and history without rebuilding the setup every time. JJ describes this as the moment Cowork stops feeling like chat and starts acting more like a collaborator.

Train Cowork on your actual communication patterns

Rather than trying to describe his writing style abstractly, JJ uses Cowork’s connectors to analyze work he has already done. The goal is not full automation. It is reducing repetitive drafting work while keeping approval and judgment human.

Connect the tools Cowork needs

JJ connects Gmail, Slack, Notion, Google Calendar, and Google Drive. Cowork can read from and act inside those systems depending on permissions.

The permission model matters here. JJ repeatedly keeps actions behind approval gates. Reading sent email does not require permission to send email. Drafting messages does not require autonomous delivery. Cowork supports granular scopes, including settings that always ask before taking action.

I frame this as progressive trust. Start with low-risk read access and add capabilities only after the outputs become consistently useful.

Generate an email-writing skill from sent mail

With Gmail connected, JJ asks Cowork to analyze emails sent during the previous 30 days and convert recurring structure, tone, and phrasing into a reusable writing skill.

This is one of the strongest demonstrations in the episode because it uses connectors for ingestion, not just action. Instead of manually writing a prompt that says sound concise but friendly, Cowork studies real examples of how JJ already communicates.

I point out that this fits naturally into what she calls an anti-to-do list: identify recurring tasks you no longer want to start from scratch, then build reusable skills around them.

"Hey, analyze my Gmail specifically the emails that I have sent in the last 30 days, and use this to create a writing skill specifically for emails that I write using, uh, my emails as an example of my writing structure. So whenever I want you to write an email in the future, you know exactly how I write my emails, and you'll use this skill."

Keep final approval human

In the demo, Cowork analyzes 46 sent messages and produces an email style guide plus a voice profile that gets saved into project memory. JJ says the results are close enough to his real writing style that the drafts already feel usable.

Even so, he keeps one standing instruction in the system: never send emails on his behalf. Cowork drafts messages and prepares them for review, but recipients, claims, attachments, and final delivery still require human approval. See Train Claude Cowork to Write Emails in Your Personal Style.

That boundary is a recurring theme throughout the workflow. JJ is comfortable giving Cowork broad context access because he separates context gathering from irreversible actions. The setup works best as a drafting and preparation layer, not an autonomous executive assistant.

Use simulated reviewers before asking real people

JJ’s sub-advisory board skill creates multiple review agents that critique the same work from different perspectives. He uses it for newsletters, strategy documents, social posts, and internal communication.

The appeal is speed. Instead of immediately scheduling feedback meetings or waiting on coworkers, he gets an instant first-pass review that exposes weak framing, missing assumptions, or audience mismatch. See Build a Multi-Persona 'Sub-Advisory Board' for Instant Feedback.

Define distinct reviewer perspectives

The quality of the output depends heavily on assigning meaningful viewpoints. Generic reviewers tend to produce repetitive feedback. JJ instead gives each agent a specific audience or concern.

For a newsletter, one reviewer might represent AI builders, another executives evaluating strategy, and another readers who are interested in AI but less technical. In other cases he creates personas around security concerns, skeptical users, or collaborators inside his company.

Turn the review pattern into a reusable skill

JJ asks Cowork to build the review process itself as a reusable skill. The system launches multiple subagents with fresh context windows, lets each evaluate the material independently, then aggregates the critiques.

I highlight why this matters for remote work. High-quality human feedback is expensive. Scheduling meetings, aligning calendars, and reviewing half-finished drafts all consume time. Simulated pre-feedback helps sharpen work before involving real stakeholders.

"I want you to build another uh, skill, and this is gonna be a review agent. For this skill, you're gonna launch a series of subagents that have each their own persona. And this can differ per the task, but an example is if we're launching a newsletter, we want to have subagents that represent our ICP. Maybe for me it would be AI builders, AI executives, and AI interested people."

Look for disagreement, not consensus

JJ runs PRDs, newsletters, and strategic writing through the panel and pays attention to where reviewers diverge. Repeated concerns often signal genuine weaknesses. Conflicting opinions can reveal hidden tradeoffs or audience tension.

He also uses this pattern inside larger workflows. His newsletter process, for example, chains together interviews, internet research, subject-line evaluation, section-specific writing rules, and final review stages before producing a draft.

The important caveat is that these are simulated perspectives, not actual customer validation. The sub-advisory board can sharpen thinking and improve drafts, especially for solo operators, but sensitive decisions still require evidence, stakeholder input, and human judgment.

Turn Cowork into a proactive morning operator

After establishing project context and reusable skills, JJ makes Cowork proactive with scheduled tasks. Instead of waiting for prompts, the system starts preparing work automatically on a cadence.

Create a recurring scheduled task

Cowork scheduled tasks can run hourly, daily, weekly, or on weekday schedules. JJ creates a recurring morning workflow instead of manually checking every tool at the start of the day.

What makes this more interesting than a normal digest is that the task runs inside the same project environment. It inherits connectors, memory, instructions, and previously built skills.

Build a morning debrief from connected tools

JJ schedules a Morning Debrief at 7:30 AM that reviews email, Slack, and calendar activity. The goal is not just summarization. Cowork identifies messages requiring attention, surfaces meeting prep needs, and proposes a plan for the day.

I broaden the use case beyond executive productivity. Scheduled tasks could deliver project updates, curated news, household reminders, wellness prompts, or planning support for entirely non-work projects. The key shift is moving from one-off chat questions to lightweight software systems that continuously work on your behalf.

"I want you every single morning to look at my email, my Slack and my calendar, and check it to help organize a plan of action for the day. So that way when I get into the office, I'm aware of any kind of messages that need my attention. You can start preparing me for my day by looking through my calendar and looking through my events, and if I need any kind of meeting prep, helping me do that."

Keep automation scoped and reviewable

JJ keeps the morning workflow primarily read-only. The task gathers context and prepares information without automatically replying or sending messages.

That design choice keeps the system useful without creating unnecessary risk. Connector scopes can evolve over time, but the workflow already delivers value before granting autonomous write access.

I repeatedly frame this as a spectrum. Some users may only want AI to draft emails. Others eventually become comfortable letting agents coordinate broader operational work. The important thing is that Cowork supports gradual expansion instead of requiring all-or-nothing automation.

Why the layered approach works

The strongest idea in JJ’s setup is not any individual prompt. It is the order of operations.

First establish stable context with projects and folders. Then convert repeated behaviors into reusable skills. Then add scheduled automation that benefits from both memory and connectors.

That layered structure solves one of the biggest problems with AI productivity tooling: constantly restating yourself. Cowork becomes more useful over time because the project accumulates preferences, examples, feedback loops, and operational history.