Module 1 · Write + Present
The idea — two modules, not four
Concept
BeWorking is one on-device workspace for the two things you actually produce: documents and presentations — plus everything you need to rehearse, record, and deliver them, with local AI where it helps. That's it. Two modules, not four.
You Write — draft the thinking, the narrative, the plan, in a focused editor built for that. You Present — turn what you wrote into a deck, rehearse it with a teleprompter, record yourself giving it, and read back a score on how you delivered it. Everything in this course lives on that one thread:
Write → Present → Deliver
Draft your thinking → turn it into slides → rehearse, record, and present it.
Each stands on its own — Write is a real editor even if you never open a slide, and Present is a real deck-building and recording tool even if you never wrote a word inside BeWorking first. But the reason they live in one app is the handoff between them: text you drafted in Write can be dropped straight into a slide in Present, so the words you actually chose end up on screen without a copy-paste detour.
Say this plainly, because it trips people up: BeWorking is not a data or spreadsheet tool. It doesn't transform CSVs, and it doesn't chart a dataset. If that's what you need — cleaning, joining, aggregating, visualizing data — that's the sibling app, BeAutomating. BeWorking's job starts once you have something to say and someone to say it to.
Keep that one line in mind for the rest of this course: Write → Present → Deliver, two modules doing one job well, not four tools bolted together.
Do it
- Open BeWorking and look at the sidebar or top navigation. Find the two modules — Write and Present.
- Click into Write, then click into Present. Notice each one looks and feels like a complete tool on its own — that's intentional. The connection between them is what this course spends the next five modules showing you.
Check
You need to clean up a messy spreadsheet and chart it. Is that a BeWorking job?
No. BeWorking has no data or spreadsheet tooling at all — it doesn't load, transform, or chart datasets. That job belongs to the sibling app, BeAutomating. BeWorking starts one step later: once you have a document or a deck you want to write, rehearse, and deliver.
Module 1 · Write + Present
Local & private, at native speed
Concept
Before you touch a single feature, it's worth understanding what's running underneath BeWorking, because it changes what you're willing to trust it with. Write and Present both run natively on your Mac — your documents and your decks are files on your machine, not records in someone else's database.
That posture shows up concretely in Write: every document you create is marked either local-only or cloud-ok. Local-only documents never leave your machine — ever, not even for a feature that would otherwise want to send them somewhere. A document marked cloud-ok is one you've explicitly decided is fine to sync or share. And the ambient intelligence layer, Gordon (you'll meet it properly in Lesson 1.3), can be toggled off entirely: when it's off, it stops observing, and nothing about your writing or presenting leaves your machine either.
Google Docs and Google Slides are cloud-first by default — your document lives on Google's servers the moment you start typing. Notion is a synced cloud database. Both trade your material's locality for convenience.
BeWorking keeps the trade off the table: Write and Present run on your Mac, at native speed, with nothing uploaded unless you explicitly mark a document cloud-ok.
Do it
- Open Write and start a new document. Find the local-only / cloud-ok marking and set it to local-only.
- Open Present and open (or start) a deck. Notice there's no sign-in wall or upload step standing between you and building a slide.
- Find where Gordon can be toggled off (you don't need to turn it off — just confirm the control exists and understand what it does).
Check
You're on a flight with no wifi. Can you still draft a document in Write and build slides in Present?
Yes. Both run natively on your Mac — there's no server round trip required to write a document or build a deck. The only things that ever need a network are features you invoke deliberately and knowingly, never something running silently in the background while you work.
Module 1 · Write + Present
Meet Write, Present & Gordon
Concept
A quick tour before you go deep on either module — just enough of each to know what it's for and where it fits in the arc from Lesson 1.1.
Write is a focused text editor built for thinking, not formatting. It watches your flow state, builds a personal "Writing DNA" baseline from your own history, scores readability locally in real time, and lets you cross-link documents with [[wiki-links]]. It's where the material usually starts.
Present is where that material becomes something you actually deliver. It's a full slide editor — drag, resize, layer, format — plus everything downstream of "the deck is built": a full-screen presenter view, a recording system with a script-reading teleprompter, a delivery-analysis report, and export. Building, rehearsing, and recording all live inside the one module.
And running underneath both, quietly, is Gordon — BeWorking's ambient intelligence layer. Gordon is not a chatbot and it has no interface you talk to directly. It works in the background, noticing patterns — a document that read clearly, a deck that scored well when you delivered it, a connection between something you wrote and a slide you later built from it — and surfaces them at natural breakpoints instead of interrupting you mid-task.
Do it
- Visit Write and find its Writing DNA indicator. Visit Present and find its slide editor and, separately, its Record tab.
- Find the Gordon panel (usually a sidebar tab) and open it, even if there's nothing in it yet. Note its four tabs: Insights, Patterns, Links, Wiki — you'll use these more in Module 5.
Check
Is Gordon a chatbot you type questions to?
No. Gordon has no chat interface at all — it works ambiently in the background, tracking writing patterns, deck and delivery patterns, and cross-module links between Write and Present, then surfacing what it notices at natural breakpoints (finishing a document, finishing a recording) rather than through a conversation you initiate. You'll see exactly what it surfaces, and how to turn it off, in Module 5.
Module 1 · Write + Present
Your first win — write it, drop it into a slide
Concept
You don't need to learn every feature before BeWorking pays off. The fastest path to a real result — a live, on-screen presentation you can actually give — is one short piece of writing and one handoff: Write, then Shared Assets, then Present. This lesson is that path, start to finish, so you leave Module 1 having actually presented something.
Here's the shape of it. You draft a line or two in Write — it doesn't need to be polished. You select it and share it as an asset. You switch to Present, open the Assets panel, and drop that shared text straight onto a slide as a ready-to-edit text element — no retyping, no copy-paste guessing about which paragraph you meant. You press Present Full Screen. That's a live presentation, built from a rough line of writing, in minutes.
This is the handoff that makes BeWorking one workspace instead of two disconnected tools: the words you chose in Write are the words that land on the slide, carried over exactly, ready for you to resize or restyle without retyping a thing.
Do it
The Day-1 flow:
- Open Write. Draft a line — even one sentence of what you want to say.
- Select it and share it as an asset.
- Switch to Present, open the Assets panel, and find what you just shared.
- Drop it onto a slide, then press Present Full Screen — you have your first live presentation.
Check
After you drop a Shared Asset onto a slide, do you need to retype it to match what you wrote in Write?
No — it lands as an editable text element carrying the exact wording you shared. You can restyle, resize, or edit it further right there on the slide, but you never have to retype the words you already chose in Write. That one handoff — write it once, drop it in — is the whole point of Module 1.
Module 2 · Write
The thinking editor
Concept
Write isn't a word processor in the Microsoft Word sense — there's no ribbon of fonts and margins to fuss over. It's closer to a thinking environment: a small set of features built specifically for people who need to think while they type, not format while they type.
The first is the Flow State Guardian. Once you've been writing uninterrupted for three or more minutes, BeWorking recognizes you're in deep focus and gets out of your way entirely — no notifications, no popups, nothing competing for your attention. The moment you pause, it surfaces a quiet flow summary: words written, time spent in flow, and your words-per-minute. Most productivity software interrupts you constantly, on the theory that a nudge here and a reminder there keeps you on track. Write does the opposite — it treats an unbroken stretch of focus as something to protect, not manage.
The second is Writing DNA. Over time, Write builds a personal baseline from your own history — your average sentence length, your passive-voice ratio, your typical readability score. When you open a new document, it quietly compares what you're writing right now to your own baseline, and tells you whether you're writing more clearly or less clearly than usual. Not against some generic "good writing" standard pulled from a style guide. Against you, on your best and worst days.
Underneath both of those sits readability scoring — every document shows a Flesch-Kincaid reading level and an estimated read time, computed locally, updated in real time as you type. No API call, no spinner, no round trip to a server. It's just continuous feedback, the same way a word count is continuous feedback, except this one tells you something about clarity instead of length.
Last is the RSVP reader — Rapid Serial Visual Presentation. Any document can be replayed one word at a time, flashing at a speed you control between 100 and 600 words per minute. It's a strange sensation the first time: you can't skim, you can't reread a clause you glossed over, you just receive the words at the pace you set. That makes it useful for two very different things — reviewing your own draft at a pace that forces real comprehension, and practicing the delivery speed of something you're about to present out loud.
Do it
- Open Write and start a new document. Write for at least three uninterrupted minutes — anything: a real draft, or just your unfiltered thoughts on the topic at hand.
- Pause. Look at the flow summary that appears — note the words written, the time in flow, and the WPM.
- Find the readability indicator (Flesch-Kincaid level + read time) and the Writing DNA comparison for this document. Note whether this draft reads clearer or less clear than your own baseline.
- Open the RSVP reader on the same document and run it for a few seconds at a comfortable speed, then try bumping it faster.
Check
Writing DNA tells you your document reads "less clearly than usual." Less clearly than what, exactly?
Less clearly than your own historical baseline — the average sentence length, passive-voice ratio, and readability score Write has built up from your past documents. It's not measuring you against a generic style guide or someone else's idea of good writing; it's measuring today's draft against your own track record, so the signal is personal rather than arbitrary.
Module 2 · Write
Wiki-links & backlinks
Concept
A single document is useful. A workspace where your documents know about each other is a different thing entirely — and that's what wiki-links give you in Write.
Type [[Document Title]] anywhere in a document, and BeWorking links it to any other document in your workspace that matches that title. No separate "insert link" dialog, no hunting for a file path — you just type the title inside double brackets, right in the flow of writing, and the connection is made.
The half of this that makes it more than a convenience is backlinks. BeWorking tracks every link you create in both directions. Open a document, and you can see every other document that references it — even ones you linked from weeks ago and forgot about. You didn't have to go maintain an index or remember where you'd mentioned this topic before; Write already knows, because it tracked the link the moment you typed it.
Put together, wiki-links and backlinks turn a folder of separate documents into a connected workspace — closer to a small knowledge graph than a stack of files. As you write more, the web of connections between your documents grows on its own, without any extra tagging or filing effort from you.
Do it
- Create a document — call it, say, "Q3 Planning."
- Create a second document — call it "Team Retro" — and somewhere in the text type
[[Q3 Planning]]. - Open "Q3 Planning" and find its backlinks panel. You should see "Team Retro" listed as a document that references it.
Check
You type [[Q3 Planning]] inside "Team Retro." Which document's backlinks panel will now show "Team Retro" listed?
"Q3 Planning"'s backlinks panel — because that's the document being referenced. Backlinks always show up on the document being pointed to, not the one doing the pointing. That's what lets you open any document and immediately see everything else in your workspace that mentions it, without having to remember or search for those connections yourself.
[[Document Title]] links any document to any other, and BeWorking tracks the reverse direction automatically as backlinks — turning a folder of separate files into one connected workspace.Module 2 · Write
Privacy by design
Concept
Not every document you write is meant to leave your machine. Write treats that as a first-class decision rather than an afterthought: every document is marked either local-only or cloud-ok.
A document marked local-only never leaves your Mac. Ever — not for sync, not for a feature that would otherwise want to send it somewhere, not for anything. A document marked cloud-ok is one you've explicitly decided is fine to sync or share. The marking lives on the document itself, so the decision travels with the file instead of depending on you remembering which folder is "the private one" this week.
It's worth asking directly: why not just use Notion or Obsidian? Both are genuinely excellent tools — Notion is a database, Obsidian is a knowledge graph, and each does its own job well. But neither one tracks your writing flow state or builds a readability baseline against your own historical writing the way Write's Flow State Guardian and Writing DNA do (Lesson 2.1). And neither one can hand your exact wording straight into a slide the way Write can — sharing a paragraph into Present as a ready-to-edit text element (Module 3) simply doesn't exist in either of those tools. Privacy-by-design in Write isn't competing with Notion or Obsidian on note-taking features alone; it's the foundation underneath a workspace that also does more with what you write.
Do it
- Open any document in Write and find its local-only / cloud-ok marking.
- Set one document you'd never want synced anywhere to local-only, and confirm the marking is visible on the document itself (not buried in a separate settings screen).
- Open a second document and compare — leave it (or set it) to cloud-ok, and notice how the two documents are visually distinguished by their marking.
Check
Which marking guarantees a document stays fully offline — never leaving your Mac?
local-only. A document marked local-only never leaves your machine, under any circumstance — no sync, no upload, no exception. cloud-ok is the opposite: an explicit opt-in that says this particular document is fine to sync or share. The marking is per-document, not a single global setting, so you can keep a private planning doc local-only while a document meant for a teammate stays cloud-ok, side by side in the same workspace.
Module 3 · Present
The slide editor
Concept
Whether a deck started from a Shared Asset dropped in from Write (Lesson 3.2) or a blank slide, you finish it in the same place: a full WYSIWYG canvas editor with drag, resize, rotate, and layer controls. Nothing about a slide is special or locked — every one is built from the same 14 element types you place by hand: title, heading, body, caption, image, icon, rectangle, circle, arrow, bar chart, line chart, table, and stat card, among others.
Text elements carry full formatting control — font family, size, bold, italic, underline, color, alignment, and line height — so a body text block or a caption reads exactly the way you want. Each slide gets its own background independent of the others: solid color, gradient, or image fill. And because slides stack elements, layer control lets you bring an element to front, send it to back, or nudge it one step forward or backward when two elements overlap.
The editor leans on standard keyboard shortcuts so you're not hunting through menus mid-flow: Delete removes the selected element, arrow keys nudge it one pixel at a time (hold Shift for a 10px nudge), Ctrl+D duplicates it, and Ctrl+C/Ctrl+V copy and paste. Undo/redo is full snapshot-based history — experiment freely, step back cleanly. And every slide has a speaker notes field: text visible to you in presenter mode but never shown on the canvas or in Present Full Screen (Lesson 4.1).
Do it
- On any slide in your deck, add a stat card element from the 14 element types and set it to one number that matters for this deck.
- Change that slide's background to a gradient fill, independent of the other slides in the deck.
- Select any element and nudge it with the arrow keys, then hold Shift and nudge again — confirm the larger 10px step.
- Add a line of speaker notes to the slide, and confirm it's visible in the notes field but doesn't appear anywhere on the slide canvas itself.
Check
You add speaker notes to a slide with a reminder to yourself about a talking point. Will your audience see that text when you present?
No. Speaker notes are per-slide text visible to you in presenter mode, but they never render on the canvas and never appear in Present Full Screen (Lesson 4.1). They're for your reference only.
Module 3 · Present
Bring your writing in
Concept
This is the lesson where the handoff you used in Lesson 1.4 becomes something you understand fully. In Write, select any piece of text — a line, a paragraph, a whole outline — and share it as an asset. It doesn't leave Write; it just becomes available to the other module.
In Present, open the Assets panel and you'll see everything you've shared from Write, most recent first. Click or drag an asset onto the current slide, and it lands as an ordinary, editable text element — sized to fit, in whatever shape matches what you wrote: a title, a body block, or a bullet list. From there it behaves exactly like any other slide element — restyle it, resize it, move it, delete it.
One thing worth being precise about: dropping a Shared Asset onto a slide is a one-time handoff, not a live link. Edit the wording on the slide afterward without touching the original document in Write. If you go back and revise the source document, the slide won't update itself — re-share the updated text from Write and drop it in again to bring the change across.
Copy-paste between two apps: you lose formatting, you lose track of which slide came from which paragraph, and there's no record of the connection once it's done.
Shared Assets: the Assets panel keeps a running list of everything you've shared, so you always know which slide traces back to which document — and Gordon quietly records the connection too (Module 5), so you can find your way back later.
Do it
- In Write, select a short paragraph and share it as an asset.
- Switch to Present, open the Assets panel, and confirm it's listed there.
- Drag or insert it onto a slide, and confirm it lands as an ordinary text element you can restyle and resize.
- Go back to Write, revise the original paragraph, and re-share it. Confirm the slide doesn't change on its own — then drop the refreshed version onto the slide (or a new one) to bring the update across.
Check
You edit the original paragraph in Write after you've already dropped it into a slide. Does the slide's text change on its own?
No. Sharing an asset is a one-time drop, not a live link — the slide element becomes an ordinary, independent piece of text the moment it lands. To bring an update across, re-share the revised text from Write and drop it in again; or just edit the slide's text directly, since it's now yours to edit either way.
Module 4 · Deliver
Present full-screen
Concept
When the deck is ready, press Present Full Screen to launch the slideshow viewer. It's deliberately minimal: left arrow and right arrow step between slides, spacebar advances, and escape exits back to the editor. Slides render at full viewport resolution, and there's no export step required to present.
That last point matters more than it sounds. Present Full Screen reads the deck file directly rather than a separately exported copy, so whatever you last touched in the slide editor — a Shared Asset you just dropped in, a wording tweak, a background swap — is exactly what you see the moment you present. There's nothing to re-export or refresh first.
Do it
- With your deck open in the slide editor, press Present Full Screen and confirm it launches at full viewport resolution with no export dialog first.
- Step through the deck using the right arrow key, then step back with the left arrow. Try spacebar to advance as well.
- Press escape and confirm it returns you cleanly to the slide editor, not to some other screen.
- Make a small edit in the slide editor — swap a word, move an element — then re-enter Present Full Screen and confirm it reflects your edit immediately.
Check
You just dropped a new Shared Asset onto slide 3 in the editor. Do you need to export or refresh anything before Present Full Screen will show it?
No. Present Full Screen reads the deck directly, not a separately exported snapshot — whatever is on the slide in the editor is exactly what you'll see the moment you present. There's no export step, no refresh button, nothing to remember before you go live.
Module 4 · Deliver
Record with the teleprompter
Concept
BeWorking's recording system isn't a screen recorder bolted onto the slide viewer — it's integrated with the slide system itself. When you hit record, it captures your presentation and your voice simultaneously, and every slide transition you make during that recording is timestamped as it happens. That timestamp data is what later powers chapter markers on export (Lesson 4.4) and lets the delivery analysis (Lesson 4.3) tell you exactly which slide you were on when your pacing changed.
The other half of the integration is the teleprompter. If you drafted a script for this presentation in Write, that script appears as a scrolling overlay during recording — you're not reading from a separate window, a phone propped against the monitor, or notecards off to the side. The overlay auto-advances at a WPM (words-per-minute) you set yourself, tunable from 60 to 250 WPM, so a deliberate, slow-paced walkthrough and a brisk, rapid-fire one both get scroll speeds that match how you actually talk.
Do it
- With your slide deck ready, open the Record tab.
- Toggle Microphone on.
- If you have a script for this deck in Write, enable Teleprompter and set a WPM between 60 and 250 that matches your natural speaking pace.
- Click Start Recording. Wait through the 3-second countdown, then present: advance slides with the arrow keys while the teleprompter scrolls your script and your audio is captured underneath it.
- Click Stop Recording when you reach your last slide.
Check
You didn't write a script for this deck in Write — you're presenting off the top of your head. Can you still record, and what do you lose?
Yes, you can still record — Teleprompter is a toggle, not a requirement. Microphone and slide capture work with it off. What you lose is the scrolling script overlay itself; you're presenting unscripted, the same way you would with any other recorder. Slide transitions are still timestamped either way, so chapter markers and delivery analysis work identically — the teleprompter only changes what you see on screen while presenting, not what gets captured or analyzed afterward.
Module 4 · Deliver
Delivery analysis
Concept
After you click Stop Recording, BeWorking analyzes your delivery, not just your content. It scores three things: speaking pace, pauses, and filler words. That scoring rolls up into a single 0–100 delivery score, but the score itself isn't the point — the specifics underneath it are. The analysis tells you where you went too fast, where you paused unexpectedly, and whether your pacing actually matched what was on the slide at that moment, because it's cross-referencing your audio against the timestamped slide transitions from Lesson 4.2.
Treat this the way you'd treat any coaching feedback: failure is feedback. A low score on a section, or a flagged run of filler words in the middle of your explanation of the hardest slide, isn't a verdict — it's a pointer to exactly where to focus your next take. Nothing about the analysis blocks you from re-recording, exporting anyway, or ignoring a flag you disagree with. It's information, not a gate.
Do it
- After stopping a recording, open the delivery report.
- Read your overall 0–100 delivery score.
- Find the pace, pauses, and filler-word breakdown underneath the score, and identify the specific slide or moment where the report flags you went too fast or paused unexpectedly.
- Note one concrete thing to improve for your next take — not a vague impression, but the specific moment the report pointed to.
Check
Your delivery score comes back low on your first take. Does BeWorking stop you from exporting that recording?
No. The delivery score is coaching, not a gate — failure is feedback. A low score, or a specific flagged pause or filler-word run, just tells you where to focus if you choose to re-record. Nothing about the analysis prevents you from exporting the take you already have (Lesson 4.4) if it's good enough for your purposes.
Module 4 · Deliver
Export
Concept
A finished recording exports as four separate files, and each one carries a different piece of what was captured. The .webm video is the recording itself — browser-native format, produced by the browser's own MediaRecorder API, no third-party SDK involved. Alongside it, a JSON timeline holds the raw metadata: every timestamped slide transition and the data the delivery analysis (Lesson 4.3) was built from. An auto-generated .srt subtitle file carries the transcription of your narration, in the standard format any video hosting platform accepts. And a chapter markers file turns those same timestamped slide transitions from Lesson 4.2 into one chapter per slide, compatible with any video player that supports chapter navigation.
All four are generated locally, on your machine, with no upload required at any step — the same local-first posture that runs through Write's privacy-by-design (Module 2) and Present's on-device slide rendering. Nothing about exporting a recording sends your video, audio, or transcript anywhere.
Do it
- From a completed recording, open the export options.
- Export the .webm video file.
- Export the JSON timeline metadata.
- Export the .srt subtitle file and the chapter markers file, and confirm all four exports completed without any upload step or network prompt.
Check
You want to load this recording into a video player and jump straight to slide 6 using chapter navigation. Which of the four exported files gives you that?
The chapter markers file. It turns the timestamped slide transitions captured during recording (Lesson 4.2) into one chapter per slide, in a format video players with chapter navigation can read. The .webm is the video itself, the JSON timeline is raw metadata, and the .srt file is subtitle text — none of those three drive a player's chapter-jump UI on their own.
Module 5 · Gordon
The ambient intelligence
Concept
Gordon is not a chatbot. There's no box to type into, no conversation to start — Gordon has no interface you interact with directly. It works in the background, watching what you do across Write and Present, and surfacing what it notices without interrupting you.
Gordon tracks four things. Writing patterns: when a document you write performs well — high readability, clear structure — Gordon saves the heading structure and style metrics as a reusable pattern you can apply to future documents. Deck patterns: decks that presented well are remembered too — slide count, pacing, structure — so building your next deck for a similar occasion starts from something that already worked, not a blank canvas. Cross-module links: when you share an asset from Write into a Present slide, Gordon records that connection so it can later surface "you wrote about this in document X — relevant here?" Delivery patterns: which decks scored well in delivery analysis (Lesson 4.3), and what pacing got you there, get remembered across recordings too.
Do it
- Open Present and reopen a deck you've already presented and recorded, or build a short one now.
- Present it and record it once, end to end.
- Open the Gordon panel (sidebar tab) and check the Patterns tab.
- Confirm your deck now appears there as a saved pattern, with its structure and delivery stats attached.
Check
You just recorded a deck for the first time and it went well. Do you need to open a chat with Gordon and ask it to save this as a pattern?
No. Gordon has no chat interface to ask anything of — it works ambiently. Because the deck presented and recorded well, Gordon saves its structure, pacing, and delivery stats as a reusable pattern on its own, in the background. You'll find it waiting in the Patterns tab of the Gordon panel; nothing about the run needed to be initiated or confirmed by you.
Module 5 · Gordon
The Gordon panel + privacy
Concept
Everything Gordon tracks (Lesson 5.1) surfaces through one place: the Gordon panel, available as a sidebar tab, organized into four tabs. Insights lists active issues sorted by severity — critical, warning, info — alongside a comparison of the current document against your Writing-DNA baseline, with one-click dismiss on anything you don't want to act on. Patterns holds your saved writing structures and deck patterns, each with usage stats attached. Links shows cross-module connections — text shared between Write and Present, as Shared Assets. Wiki shows every outgoing [[wiki-link]] from the current document, plus every document that links back to it.
Gordon can be toggled off entirely. When it's off, it stops observing and stops surfacing suggestions — no insights, no new patterns saved, no link tracking. And this isn't just a UI pause: your content and behavior data never leave your machine in the first place, on or off. Turning Gordon off doesn't "stop an upload" because there was never an upload to stop; it stops the local observation itself.
Do it
- Open the Gordon panel and click through all four tabs in order: Insights, Patterns, Links, Wiki.
- On Insights, find one issue and note its severity (critical, warning, or info), then try the one-click dismiss.
- On Wiki, open a document that has at least one
[[wiki-link]]and confirm you see both its outgoing links and its backlinks. - Find the Gordon on/off toggle and switch it off, then back on.
Check
You toggle Gordon off. What happens to the writing and behavior data it had been tracking?
Nothing leaves your machine — it never did, on or off. Toggling Gordon off simply stops it from observing and surfacing new suggestions: no new insights, patterns, or links get recorded going forward. There's no upload to disable, because Gordon's tracking was local-only from the start.
Module 6 · Putting it together
Write → Present → Deliver
Concept
Every lesson so far has taught you one piece: a document in Write, a Shared Asset dropped into a slide, a deck built in the slide editor, a rehearsal with the teleprompter, a recording, a delivery score. This lesson doesn't teach a new feature. It threads all of them into the one loop BeWorking was actually built for, on something that's yours to say — not a sample deck.
Here's the full shape. In Write, you draft the document — the narrative, the plan, the update, whatever you're about to deliver. You share the parts you want on slides as assets. In Present, you drop those assets onto slides and finish the deck by hand in the slide editor. You rehearse with the teleprompter, reading straight from the same document you drafted — you never wrote the words twice. You record, and every slide transition gets timestamped as you go. You present full-screen, live, whenever the moment calls for it, reading directly from the current deck. And afterward you read your delivery score, not as a grade, but as a pointer to what to sharpen next time.
A doc app, a slide app, and a separate screen recorder: three disconnected tools. You retype your outline into the deck, hunt for a script to read from while recording, and there's no record anywhere of which recording belongs to which draft.
BeWorking: one workspace, one loop. The words you wrote are the words on the slide and the words the teleprompter reads back to you — write once, reuse everywhere downstream.
Do it
Reproduce the loop with something you'd actually deliver:
- In Write, draft a short document — real material, not a placeholder.
- Share the parts you want on slides as assets, then switch to Present and drop them in. Finish the deck in the slide editor.
- Enable the Teleprompter with this same document as your script, and rehearse it once.
- Open the Record tab and record yourself giving it.
- Read the delivery score that comes back, and note one specific thing the report flagged.
Check
Which two steps in this loop both read directly from the same document you drafted in Write?
The Shared Asset you dropped onto the slide, and the teleprompter script during recording — both draw from the same document. You only wrote your material once; Present and the teleprompter each reused it, in a different form, without you retyping a word.
Module 6 · Putting it together
Your workflow from here
Concept
Now that you've run the whole loop once, the more useful question isn't "what does each feature do" — you know that already. It's "how do you actually work, going forward." The answer is a progression, not a single mode.
Do it yourself first. Draft the document, build the deck, present it cold, record it, and read your own delivery score without leaning on any assist. You need that baseline — it's the same reasoning behind Writing DNA (Lesson 2.1) comparing you against your own history, not a generic standard. Then let Gordon assist. Reuse a deck pattern instead of building from scratch (Lesson 5.1). Use the teleprompter instead of memorizing. Read the delivery report as coaching, not a verdict — Lesson 4.3's core lesson, failure is feedback, applies to your presenting just as much as to a low readability score. Then share it. Export the four files (Lesson 4.4) or hand the deck and the recording to a teammate.
Underneath all three stages sits the same guarantee, stated plainly at the start of Module 1 and true at every step since: your material never leaves your Mac. Write's local-only marking (Lesson 2.3), Present's on-device slide editor and recorder, Gordon's on-machine-only tracking (Lesson 5.2), and Export's four locally-generated files with no upload (Lesson 4.4) — nothing you wrote, presented, or recorded goes anywhere you didn't choose to send it yourself.
Do it
Define one real recurring workflow — something you actually do, not a one-off exercise:
- Name it: the thing you currently redo by hand on a schedule — a weekly team update, a monthly client check-in, a recurring standup summary, a talk you give more than once.
- Sketch its BeWorking shape in one sentence: what you'll draft in Write, what the deck is called, who you'll eventually record it for.
- Self: run it once end to end without any assist — draft in Write, build the deck, present, record, read your own delivery score.
- AI: run it again leaning on Gordon — reuse a saved pattern, use the teleprompter, and read the delivery report as a coaching note rather than a grade.
- Others: export the recording's four files (Lesson 4.4), and plan the moment you'll hand the deck or the recording to one real person.
Check
Next week, your recurring workflow comes around again — new content, same shape. Do you rebuild the deck from scratch?
No. Because the deck you built the first time presented and recorded well, Gordon already saved it as a reusable pattern (Lesson 5.1) — you'll find it in the Patterns tab with its structure intact. You draft this week's material in Write, share the new assets in, and reuse the deck's shape. What used to mean rebuilding a slide deck from a blank canvas every time becomes: write it, drop it in, deliver it.