workflow

Automations become infrastructure without anyone deciding they should. This lesson covers shadow automation and why banning it fails, documenting a flow so it survives its author, the signals that a workflow has outgrown no-code, and how to migrate without a rewrite.

The concrete patterns that separate an automation that works from one that keeps working: validating input at the boundary, retrying only what is safe to retry, handling rate limits and batches, testing something you cannot easily test, and keeping secrets out of the flow.

No-code automation makes building easy and running reliably hard. This lesson covers what these platforms actually are, the failure modes that appear once something runs unattended, why partial failure is worse than total failure, and the idempotency problem behind most real damage.

The concrete workflows: triaging an inbox that is not yours, building briefing packs, handling travel and what happens when it breaks, and producing documents. What each needs as input, where each fails, and what has to stay with a person.

Executive assistance looks like a set of logistical tasks and is mostly judgement about priority, access and relationships. This lesson separates the mechanical work from the discretionary work, and explains why the parts that automate cleanly are not the parts the role is valued for.

Supply chain systems handle the normal case; people handle everything else. This lesson covers why exception volume is the real workload, how to triage without automating away judgement, what a control tower does and does not solve, and why visibility is usually a data problem rather than a modelling one.

Documentation is the biggest consumer of hours in a practice and the clearest place tooling helps. This lesson covers specification drafting and why a spec is a legal instrument, submittal and datasheet review, request-for-information handling, and the coordination problem between drawings and specs.

The advisory workflows in detail: framing an issue, running research so the model finds authority instead of inventing it, drafting a memo that does the job a memo exists to do, reviewing documents for tax consequences, and turning a technical position into something a client can act on.

The four workflows that recover the most advisor time: preparing for a review, capturing and documenting the meeting, producing client-ready written output, and digesting research. What each needs as input, where the Marketing Rule engages, and the review that has to happen before anything reaches a client.

The four workflows where AI changes an agent's day: producing listing content across formats, handling inbound enquiries at speed, assembling a comparative market analysis, and keeping a transaction chain visible. What each one needs as input, where it fails, and what has to stay human.

Where AI actually helps an HR function, and where it creates exposure that outweighs the gain. This lesson works through the lifecycle: sourcing and job descriptions, the screening decisions that determine everything, interview support, onboarding as the best early deployment, and performance work where the label problem returns.

A redesign has to be introduced into a process that is still running and still has customers. This lesson covers sequencing, running the old and new paths together, the counterweight metrics that catch a hollow win, the failure modes that end these efforts, and how to know when not to redesign at all.

When one step becomes cheap, the optimal shape of the whole process changes. This lesson covers the six moves that follow, why the review stage almost always needs relocating, what business process reengineering actually taught, and the honest state of the evidence on how often these efforts succeed.

You cannot redesign a process you have not observed, and the documented process is rarely the real one. This lesson covers task-level decomposition, finding where time and waiting actually go, identifying the constraint that governs throughput, and the measurements to take before any AI is introduced.

The everyday SVN commands and the model behind them. Covers the update-edit-commit cycle, status codes and diffs, the copy-modify-merge approach to conflicts, locking for unmergeable binary files, useful properties like svn:ignore, and how to undo changes safely.

Most store work is repetitive reaction: tag this order, email that customer, reorder when stock drops. Shopify Flow turns that into automation with a trigger-condition-action model. This lesson covers how Flow works, over 100 event triggers, worked workflows, and the important part, where Flow stops and you need something else.

What modern AI dev tools actually do, where they sit on a spectrum from inline completion to autonomous agents, and the workflow habits that separate developers who 2x their output from developers who ship subtly broken code.