week 1 with claude code (for work)

I (finally!) got access to Claude Code officially at work. I’ve been feeling a bit behind the curve since it seems like most product teams have had licenses for months. So I’ve been trying to lock in and play catch up by exhaustively learning and applying ways I can automate my routine execution tasks so I can focus more on the judgment, taste, and influence aspects of the job.

Here is a day-by-day breakdown of exactly how I set that up over my first week:

We didn’t have access to Enterprise yet, so I only installed Claude on my terminal and used their API usage billing to get credentials. I personally prefer running Claude directly within an IDE like Cursor. By keeping Claude open in a terminal side-panel, I maintain context on the active directory and open files as visual cues while I chat with Claude.

Below is my personal setup that with Cursor as an IDE + Claude opened in the terminal as a side panel:

When it comes to setting up MCPs, I first set up Figma and Jira since those were the two applications I’d been interfacing with the most in my day to day. Below is the exact process I used (including some trial-and-error learnings) to connect an MCP, using Notion as the example:

1. Fetch the command: Copy the specific installation command from Claude Code’s MCP documentation for your target server.

2. Execute: Paste and run the command in your terminal.

3. Re-initialize: You will likely need to restart the session for the MCP to register. You can either start a new session entirely or kill the current one using Ctrl + C on Mac.

4. Verify: Type /mcp in the terminal to view your active list of connected servers.

5. Authenticate: Hit authenticate. This opens a new browser window (or tab) where you’ll authorize the connection.

6. Confirm: You’ll know the handshake was successful when you see an “Authentication Successful” message in the browser, mirrored by an “Authentication successful. Connected to [MCP name].” prompt in your terminal.

I knew from a recent PM webinar that building reusable “skills” was the key to maximizing use out of Claude Code for PMs, but the optimal directory structure to enable that wasn’t immediately obvious.

When I prompted Claude to create my first skill to write weekly program review updates, it defaulted to a global setup, storing the skill at the root level of my laptop. I had to explicitly course-correct the LLM to adopt a project-local architecture, ensuring that my AI skills and knowledge were isolated within the specific project folder.

After a few steering prompts, I landed on this directory structure:

In retrospect, I should have treated the folder structure itself as a product feature. If I were starting over, I would spend more time upfront using Claude’s /plan mode to architect an optimal, scalable folder hierarchy before writing any markdown files.

I came into Day 3 pretty ambitious. My initial instinct was to create dozens of skills right out of the gate, but I realized that skills are less useful without the right context. So I started migrating a few of my core work artifacts into the .claude/knowledge/ directory to test against my skills.

Here’s the data ingestion workflow I used to convert my knowledge into a machine-readable format:

1. Dump the unstructured data: I created raw Markdown files and pasted in messy, unformatted text. Some examples of the context I brought over included raw Zoom audio transcripts, existing product strategy documents, and deep research outputs generated via Gemini.

2. Build formatting skills: Rather than manually cleaning this data, I built a few foundational skills specifically designed to parse and normalize raw text into structured frameworks.

3. Execute the cleanup: Using Claude Code, I invoked the formatting skill in the terminal and used the @ reference to point the AI directly at the .md file to rewrite it.

With my context properly ingested, the directory started to look like this:

With my .claude/knowledge/ directory populated, I was ready to start executing workflows. I wanted to break down the types of cognitive tasks Claude Code could handle. Instead of just looking at what the AI can “type,” I started framing my skills around the level of cognitive load they remove from my plate.

These fall into three distinct tiers, scaling from basic data processing to advanced critical evaluation:

• Example skill: /format-zoom-transcript

• Reasoning effort: Low

• Task scope: High volume

AI just needs to parse a massive amount of messy, unstructured data (like the raw transcripts) and format it into a clean, legible structure. I personally benefit from these types of skills by reclaiming energy it takes to parse through meeting minutes and manually pick out important information like action items.

Raw input

Output

• Example skill: /write-decision-doc

• Reasoning effort: Medium

• Task scope: High organization

AI is taking on the cognitive load that I’d typically bear when organizing an argument from the logical structuring to the trade-off articulation. Instead, I’m able to focus strictly on the content and information gathering from stakeholders.

Here is an example skill file I use:

• Example skill: /review-product-strategy

• Reasoning effort: High

• Task scope: High complexity

This is the most advanced cognitive tier where AI acts as a strategic thought partner. To do this, AI uses multiple contexts at once (such as leveraging competitive research files and customer transcripts) and evaluate a net-new artifact against them. This can be used to pressure-test work and avoid blind spots by checking the strategy against any real-world realities that may have been overlooked.

This evening, I was moderating an alumni panel for the Intuit RPM/RDP 20th Anniversary. Because this panel was a one-time event, I figured the ROI of building a dedicated skill and saving it to my .claude directory wasn’t there.

Instead, I spun up a new terminal session as a new node purely for ad-hoc prep. The organizing team had curated a list of great questions for the panelists, but I felt some were phrased too formally for me to deliver them naturally.

So I fed the questions into Claude and used it for stylistic alignment, prompting it to rewrite the question to match my natural speaking voice and ensure the moderation felt conversational rather than scripted. It did pretty well for a few of them, but there were one of two where I needed to course-correct by providing it feedback.

Example:

Before:

In transitioning from a highly structured enterprise environment to founding an early-stage startup, which established product management methodologies did you find counterproductive and subsequently have to unlearn?

After:

Intuit teaches us incredible frameworks for building products at scale for hundreds of thousands of customers. But going to zero-to-one or even one-to-ten is a totally different beast. As a founder, what Intuit skills did you quickly realize you had to unlearn to scale your startup?

I came across Pawel Huryn’s well-known repository of pre-built PM skills and decided to port them directly into my workspace. It felt like a massive shortcut, but it quickly highlighted a few realities about how AI actually integrates into product work.

First, PM work is inherently cyclical. You aren’t writing vision docs, sizing features, or running sprint retros every single day. Because of this natural cadence, I haven’t been able to organically battle-test this massive library of new skills to gauge their actual quality.

Second, while community-built skills are a great baseline, they are fundamentally generic. They don’t naturally conform to the specific cultural DNA of your company, in my case, the “Intuit way” of communicating, structuring arguments, and driving alignment. The plug-and-play approach doesn’t always work for nuanced product workflows. It’ll need some fine-tuning.

Moving forward, my best practice for creating AI skills is a chat-first prototyping model:

1. Execute Manually: Run the task organically in a standard chat session first.

2. Iterate and Calibrate: Course-correct the AI’s tone, formatting, and logic until the output perfectly matches your company’s internal standards.

3. Codify: Once the output is perfect, prompt Claude with something like: “Extract the rules, formatting, and logic from this conversation and generate a skill.md file in my .claude directory so I can replicate this exact workflow next time.”

By treating the chat window as a sandbox, you ensure that every skill you officially save to your directory is already proven, tailored, and highly relevant to your actual day-to-day work.

An example of a /edit-writing skill (had to ask Claude Code to simulate the conversation heh):

Next week, I’m hoping to continue expanding on the skills I’ve created, codifying knowledge, QA-ing the skills, and exploring more advanced features like agent teams 👾