Learning to Work With AI
Many lawyers expect AI to solve a legal problem at the click of a button. When it doesn't, they assume somebody else has found the right prompt, and the hunt for the "prompt of the week" begins. I think that hunt is a symptom of a broader problem: a lack of AI literacy.
Access to a tool doesn't tell you what it can do, where it breaks, or how people get good results from it. A firm that buys a platform or books a course hasn't finished the job either.
I want lawyers to understand the tools they use, know how to instruct and check them, and recognize when a problem needs technical or organizational help. None of that requires training models or writing code. Amid all the discussion about AI threatening young professionals' prospects, I think learning to work well with it could give junior lawyers an edge. They have a chance to develop AI proficiency early in their careers and build working methods that use these new tools as legal and tax work changes. But being younger doesn't automatically make someone good at using AI, and producing unchecked work faster is hardly an advantage. As AI automates more of the work, I expect legal judgment, supervision, and responsibility to matter even more, and earlier in a lawyer's career. More of the job will involve directing the work and checking its results.
I decided to write this series about practical AI skills for lawyers and firms to explain current good practices and the reasoning behind them.
For the examples, I'll mainly use general-purpose tools such as Codex, Claude Code, or Claude Cowork, because they cover the capabilities I want to discuss and let you influence the sources, instructions, and working context. Once you're familiar with those capabilities, adapting to another tool should be easier. The principles also help you assess a legal-specific platform, though some changes would depend on the vendor or your administrator.
The working methods come from my own habits, experiments, and what I've learned, adapted here to legal and tax work.
The series will cover:
- Understanding the system you use.
- Shaping the work you give it.
- Directing and evaluating the results.
- Turning experiments into everyday practice.
- Developing the people and organization that sustain it.
In earlier posts, I mainly explained how agents work. Here I focus on everyday habits: checking what they consulted and read, keeping unrelated tasks separate, and preserving reviewed context when returning to unfinished work. The aim is to make the results more reliable and better aligned with the task's requirements.
The Model Is Only One Part of the System
The model is the trained component. What you use is that model inside a working environment. The interface presents the two as one, whether you're using Claude Cowork, Codex, or another tool.
Think of an associate. The same capable associate does very different work depending on what the office gives them: which files they can open, which databases they can search, how well the scanner works, what the partner wrote in the instructions. Put a strong associate in a room with none of the sources and even a straightforward assignment gets difficult.
For an agent, the equipment includes tools, for example to read and write files, search the web, and run commands. A programming environment lets it execute Python or other code: to compare documents, extract data, or check calculations. I've explained how the model calls tools and uses their results in What Agents Need (And What They Actually Are).
Connections determine which other systems it can work with. An API is an interface that lets programs interact; MCP is a standard for making tools and data available to agents. Depending on the setup, a connection might let the agent query a database or retrieve documents from another system. Task-specific capabilities, such as converting a scanned document into usable text, can come from programs it calls through these tools.
Then there's the information: where sources live, how the project is structured, which instructions the agent receives, and what it has in the current session's context. Some products also retain information through persistent memory. Available isn't the same as read. An agent can reach a folder and never open the one document that matters. This is why I use a short instruction file to explain the project and point to relevant material, as described in Map, Not Manual.
If the agent has no route to a source, better prompt wording won't create one. Adding every available connection doesn't solve the problem either. A task involving documents already in a folder may need no external connection at all.
Getting familiar with your environment means going beyond selecting a model. You don't have to begin by reading online documentation. Simply ask the agent to explain the tools it has, what each is good for, and when it would use them. Describe your regular tasks and ask which existing tools could help and which capabilities would need adding.
If a particular tool looks useful for one of your tasks or workflows, ask the agent to try it so you can see whether and how it works. Use an environment approved for the task and its data. When exploring an unapproved tool, use public or synthetic material.
At the end of each session where you've done meaningful work, ask what worked, what didn't, and what would have helped. In my coding setup, I use a skill called /retro to run that retrospective and propose improvements.
A skill is a reusable set of instructions for a workflow. I explain how to build one in Encoding Legal Expertise into AI Agent Skills.
Ask for concrete moments from the session, so you can check the explanation against what happened.
Give the Agent Sources to Consult
Models have a training cutoff date. Changes in the law after that date aren't part of what the model learned during that training. Unless you supply them or the agent looks them up, it has no reliable basis for knowing about them. Even before the cutoff, it may have learned an incomplete or incorrect account. Asking a legal question without giving the agent appropriate sources leaves you in open water.
The simplest start is basic context. State the jurisdiction and the period or version of the law that applies, and for a legal project record that in the instruction file your tool supports. Map, Not Manual shows how. Naming the jurisdiction narrows the assignment, but it supplies no legal sources.
For legal sources, I recommend a curated knowledge base of the sources you or your firm would rely on. One option is to make that collection searchable through retrieval tools exposed via an MCP connection, so the agent can find and retrieve relevant passages.
Without that setup, a curated folder is enough to start. Have the agent help assemble it, within the access you've been given, and write an index listing each source's scope, version or applicable period, and location. You review the selection and the index, because the agent shouldn't decide what counts as authority. Afterwards it reads the index and opens what's relevant instead of loading everything.
Without a collection, point the agent to the specific online resources that matter and have it consult them with a web tool. For a short source, pasting the relevant text works too. That's targeted consultation, not open-ended discovery. Neither a general search nor an official website tells you which law applies to your question.
Then check what happened. Look at what the agent retrieved or opened, whether the jurisdiction and version match your question, and whether the passage supports the claim. A connector, an index entry, a citation, or a retrieval date proves none of that. Even a well-built collection guarantees neither coverage nor correct application.
The firm also needs to decide how to make those sources available to agents: through retrieval tools exposed via MCP, a direct API, or a shared folder. A lawyer can select and maintain a small collection; a firm-wide resource needs an owner and support. The firm also needs rules about what may leave in a web query.
Check What the Agent Reads From Your Documents
I've worked with scanned Steuerbescheide (German tax assessment notices), and I know how awkward they can be to examine. With tax authorities across 16 German states using different formats, you can't rely on a single layout. Tables, amounts, and notes appear in unfamiliar arrangements, and the notices I work with are scans of documents received by ordinary mail. The agent needs to read the page and preserve its structure.
Getting usable text out of a page image takes text recognition. Keeping the structure is a separate problem. Headings, rows, amounts, and notes have to stay together, or a figure ends up next to the wrong label. Digitally generated documents can lose structure in extraction too. Readable content is a precondition for reliable agent work, and a better prompt won't repair it afterwards.
Scale matters too. Reading one page successfully doesn't tell you whether the same approach can handle hundreds of notices at an acceptable speed and cost.
Start with what your firm has already approved. Does the document system, the scanner software, or the AI product you use extract text and tables well enough for these documents? Firm users often can't install software or change how documents are processed, so this is a conversation with the technical owner about a supported route.
On my own machine, I run Docling, a document converter, locally, and a skill tells my agent when to call it. The skill only guides. Docling does the reading. In a managed firm environment, the equivalent capability needs approval and support from whoever runs the systems. For more on extraction, see AI Progress Beyond Model Launches.
If approved extraction is missing or inadequate, the model's own image reading can be a fallback where your product supports it. Image reading can be slow or costly on a long document. Compare the supported approaches on your actual documents. Whichever route you use, check consequential amounts, dates, qualifications, and table relationships against the page.
If the firm's document extraction is inadequate, say so and ask for an approved way to turn scans and tables into content the agent can use and you can verify, instead of leaving each user to improvise. Find out where the processing happens and which data it's approved for.
A New Task Gets a New Session
When I switch to a different task, or to a separable subtask within a broader assignment, I start a new session. A continuing conversation carries earlier instructions, assumptions, and side discussions into work where they may no longer belong.
The model's context window is finite: instructions, conversation, source material, and tool results share a limited working space. Even before it fills up, a model can become less reliable at using relevant details as the context grows, a problem often called "context rot." Compaction is common in agent tools: they make room by summarizing the conversation. That can help a session continue, but you may not see exactly what was retained, and the summary can omit an important constraint or unresolved question.
I don't start fresh on a schedule or after a set number of messages. The trigger is the task.
When returning to unfinished work, I use a skill that asks the agent to create a handoff document for continuity. A useful handoff document records the objective, the decisions made, the relevant sources, the current state, the unresolved questions, and the next step. Read it before relying on it, especially anything presented as settled. A summary can state a guess as a decision.
Keep the handoff with the working material, in a file such as HANDOFF.md in the project's folder. Setting up that workspace properly is a topic for a later post. In the new session, tell the agent explicitly to read the handoff and the relevant sources. A reviewed summary gives it orientation without dragging the whole previous conversation along. It doesn't replace the sources.
By the way, I don't use a dedicated plan mode at all. I give planning its own session in the normal editing mode, then start a new session for the next stage using the reviewed handoff. The agent can write that document without my having to switch modes.
To find earlier conversations, I give sessions recognizable names and look them up in the tool's session history. History helps me recover a discussion or revisit a decision. It doesn't hand that conversation to a new session, and it doesn't mean the agent can search it. Old discussions can contain decisions that were later superseded, so I bring across what's relevant and check it.
Before the agent continues, ask where the work stands, what remains unresolved, and which sources it actually read. Correct what's missing now, not after the work is done. A plausible summary doesn't prove the agent read anything, so look for evidence such as the files it opened.
One boundary matters. A new conversation doesn't delete workspace files or necessarily clear persistent memory or project instructions. Naming, history, loading, and reset behavior differ between products, so check what yours does before relying on any of this.
Where to Start
Use your next ordinary task. Before you begin, check which sources the agent should consult, whether it can read the documents, and whether earlier work belongs in this session. Fix the gap that matters for that task, not everything at once.
When the task or session is done, use the retrospective I described earlier to identify one thing that would have made the task easier or the result more dependable.
Point the agent to a source, give it a reviewed handoff document, or ask the technical owner for an approved way to extract text from scans. Have the agent propose improvements before you decide what to change. Leaders need enough understanding to judge requests for better tools and connections, because buying access to a product doesn't finish the job.
Understanding the system leaves a harder question: which work to give it, with which context, and by which criteria you'll judge the result. That's next in the series.