From 31af7b792abbb5fd1bec9e6ed2e11011604e2d00 Mon Sep 17 00:00:00 2001 From: Abreham Gezahegn Date: Mon, 16 Jun 2025 22:43:54 +0300 Subject: [PATCH 1/3] expose page delimiter --- .../vite_basic/public/test_document.json | 11105 +++++++++++++++- typescript/examples/vite_basic/src/App.tsx | 13 +- typescript/src/index.ts | 17 +- typescript/src/renderer/JsonDocRenderer.tsx | 15 +- .../src/renderer/components/BlockRenderer.tsx | 1 - typescript/src/renderer/index.ts | 4 +- 6 files changed, 10574 insertions(+), 581 deletions(-) diff --git a/typescript/examples/vite_basic/public/test_document.json b/typescript/examples/vite_basic/public/test_document.json index b5718b2..f936f5e 100644 --- a/typescript/examples/vite_basic/public/test_document.json +++ b/typescript/examples/vite_basic/public/test_document.json @@ -1,1285 +1,11250 @@ { "object": "page", - "id": "be633bf1-dfa0-436d-b259-571129a590e5", - "created_time": "2022-10-24T22:54:00Z", - "last_edited_time": "2023-03-08T18:25:00Z", + "id": "pg_01jxwgvydte529fc529983j6rv", + "created_time": "2025-06-16T14:04:08.260514Z", "created_by": { "object": "user", - "id": "c2f20311-9e54-4d11-8c79-7398424ae41e" + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" }, - "last_edited_by": { - "object": "user", - "id": "9188c6a5-7381-452f-b3dc-d4865aa89bdf" - }, - "icon": { - "type": "emoji", - "emoji": "🐞" - }, - "archived": false, - "in_trash": false, "properties": { "title": { - "id": "title", "type": "title", "title": [ { "type": "text", "text": { - "content": "Test document", - "link": null + "content": "ANTHROP\\C" + }, + "annotations": {}, + "plain_text": "ANTHROP\\C" + } + ] + } + }, + "children": [ + { + "object": "block", + "id": "bk_01jxwgvydvf8zts3qzst8nbkcq", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.263728Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 1 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "ANTHROP\\C" + }, + "annotations": { + "bold": true + }, + "plain_text": "ANTHROP\\C" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvydwefc84ns1gk33hs0k", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.263958Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 1 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "How Anthropic teams use Claude Code " + }, + "annotations": {}, + "plain_text": "How Anthropic teams use Claude Code " + }, + { + "type": "text", + "text": { + "content": "How Anthropic teams use Claude Code" + }, + "annotations": { + "bold": true + }, + "plain_text": "How Anthropic teams use Claude Code" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvydxeh6bcf6jy88wj8dz", + "type": "image", + "created_time": "2025-06-16T14:04:08.264088Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "image": { + "type": "external", + "external": { + "url": "textcortex://images/img_0286jh1k578bgrewdyb2jsayr2" + }, + "caption": [] + } + }, + { + "object": "block", + "id": "bk_01jxwgvydyfj6rhm125q1rd4h8", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.264373Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 1 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Anthropic's internal teams are transforming their workflows with Claude Code, enabling developers and non-technical staff to tackle complex projects, automate tasks, and bridge skill gaps that previously limited their productivity. Anthropic's internal teams are transforming their workflows with Claude Code, enabling developers and non-technical staff to tackle complex projects, automate tasks, and bridge skill gaps that previously limited their productivity." + }, + "annotations": {}, + "plain_text": "Anthropic's internal teams are transforming their workflows with Claude Code, enabling developers and non-technical staff to tackle complex projects, automate tasks, and bridge skill gaps that previously limited their productivity. Anthropic's internal teams are transforming their workflows with Claude Code, enabling developers and non-technical staff to tackle complex projects, automate tasks, and bridge skill gaps that previously limited their productivity." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvydze3bsy2p19cfteqge", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.264524Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 1 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Through interviews with our own Claude Code power users, we've gathered insights on how different departments leverage Claude Code, its impact on their work, and tips for other organizations considering adoption. Through interviews with our own Claude Code power users, we've gathered insights on how different departments leverage Claude Code, its impact on their work, and tips for other organizations considering adoption." + }, + "annotations": {}, + "plain_text": "Through interviews with our own Claude Code power users, we've gathered insights on how different departments leverage Claude Code, its impact on their work, and tips for other organizations considering adoption. Through interviews with our own Claude Code power users, we've gathered insights on how different departments leverage Claude Code, its impact on their work, and tips for other organizations considering adoption." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye1ev5az938macfm19m", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.268864Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Contents" + }, + "annotations": { + "bold": true + }, + "plain_text": "Contents" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyecfhrtptezy19ksk3e", + "type": "table", + "created_time": "2025-06-16T14:04:08.273032Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table": { + "has_column_header": true, + "has_row_header": false + }, + "children": [ + { + "object": "block", + "id": "bk_01jxwgvye2fntaygbn4mjhskae", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.269507Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [ + { + "type": "text", + "text": { + "content": "Contents Contents" + }, + "annotations": {}, + "plain_text": "Contents Contents" + }, + { + "type": "text", + "text": { + "content": "Contents Contents" + }, + "annotations": {}, + "plain_text": "Contents Contents" + } + ], + [ + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure Claude Code for data infrastructure" + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure Claude Code for data infrastructure" + } + ], + [ + { + "type": "text", + "text": { + "content": "3 3" + }, + "annotations": {}, + "plain_text": "3 3" + }, + { + "type": "text", + "text": { + "content": "3 3" + }, + "annotations": {}, + "plain_text": "3 3" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye3etzsdxh1rp4bvqeg", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.269843Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [ + { + "type": "text", + "text": { + "content": "Claude Code for product development Claude Code for product development" + }, + "annotations": {}, + "plain_text": "Claude Code for product development Claude Code for product development" + }, + { + "type": "text", + "text": { + "content": "Claude Code for product development Claude Code for product development" + }, + "annotations": {}, + "plain_text": "Claude Code for product development Claude Code for product development" + } + ], + [ + { + "type": "text", + "text": { + "content": "5 5" + }, + "annotations": {}, + "plain_text": "5 5" + }, + { + "type": "text", + "text": { + "content": "5 5" + }, + "annotations": {}, + "plain_text": "5 5" + } + ], + [] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye4et6vxx2h6knwa3cp", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.270192Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" }, - "annotations": { - "bold": false, - "italic": false, - "strikethrough": false, - "underline": false, - "code": false, - "color": "default" + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for security engineering Claude Code for security engineering" + }, + "annotations": {}, + "plain_text": "Claude Code for security engineering Claude Code for security engineering" + }, + { + "type": "text", + "text": { + "content": "Claude Code for security engineering Claude Code for security engineering" + }, + "annotations": {}, + "plain_text": "Claude Code for security engineering Claude Code for security engineering" + } + ], + [ + { + "type": "text", + "text": { + "content": "7 7" + }, + "annotations": {}, + "plain_text": "7 7" + }, + { + "type": "text", + "text": { + "content": "7 7" + }, + "annotations": {}, + "plain_text": "7 7" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye5e6f9sgcn0qn0swsb", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.270545Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for inference Claude Code for inference" + }, + "annotations": {}, + "plain_text": "Claude Code for inference Claude Code for inference" + }, + { + "type": "text", + "text": { + "content": "Claude Code for inference Claude Code for inference" + }, + "annotations": {}, + "plain_text": "Claude Code for inference Claude Code for inference" + } + ], + [ + { + "type": "text", + "text": { + "content": "9 9" + }, + "annotations": {}, + "plain_text": "9 9" + }, + { + "type": "text", + "text": { + "content": "9 9" + }, + "annotations": {}, + "plain_text": "9 9" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye6er08spmyxj99f6cp", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.270900Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for data science and visualization Claude Code for data science and visualization" + }, + "annotations": {}, + "plain_text": "Claude Code for data science and visualization Claude Code for data science and visualization" + }, + { + "type": "text", + "text": { + "content": "Claude Code for data science and visualization Claude Code for data science and visualization" + }, + "annotations": {}, + "plain_text": "Claude Code for data science and visualization Claude Code for data science and visualization" + } + ], + [ + { + "type": "text", + "text": { + "content": "11 11" + }, + "annotations": {}, + "plain_text": "11 11" + }, + { + "type": "text", + "text": { + "content": "11 11" + }, + "annotations": {}, + "plain_text": "11 11" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye7enfv6k9jsrk6j0kn", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.271361Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for API Claude Code for API" + }, + "annotations": {}, + "plain_text": "Claude Code for API Claude Code for API" + }, + { + "type": "text", + "text": { + "content": "Claude Code for API Claude Code for API" + }, + "annotations": {}, + "plain_text": "Claude Code for API Claude Code for API" + } + ], + [ + { + "type": "text", + "text": { + "content": "13 13" + }, + "annotations": {}, + "plain_text": "13 13" + }, + { + "type": "text", + "text": { + "content": "13 13" + }, + "annotations": {}, + "plain_text": "13 13" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye8fsxb8bwm5dsdcvv8", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.271716Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for growth marketing Claude Code for growth marketing" + }, + "annotations": {}, + "plain_text": "Claude Code for growth marketing Claude Code for growth marketing" + }, + { + "type": "text", + "text": { + "content": "Claude Code for growth marketing Claude Code for growth marketing" + }, + "annotations": {}, + "plain_text": "Claude Code for growth marketing Claude Code for growth marketing" + } + ], + [ + { + "type": "text", + "text": { + "content": "15 15" + }, + "annotations": {}, + "plain_text": "15 15" + }, + { + "type": "text", + "text": { + "content": "15 15" + }, + "annotations": {}, + "plain_text": "15 15" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvye9fc6a7agvfkex0b2d", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.272071Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for product design Claude Code for product design" + }, + "annotations": {}, + "plain_text": "Claude Code for product design Claude Code for product design" + }, + { + "type": "text", + "text": { + "content": "Claude Code for product design Claude Code for product design" + }, + "annotations": {}, + "plain_text": "Claude Code for product design Claude Code for product design" + } + ], + [ + { + "type": "text", + "text": { + "content": "17 17" + }, + "annotations": {}, + "plain_text": "17 17" + }, + { + "type": "text", + "text": { + "content": "17 17" + }, + "annotations": {}, + "plain_text": "17 17" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeaeyv8nnrrm62adr20", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.272444Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for RL engineering Claude Code for RL engineering" + }, + "annotations": {}, + "plain_text": "Claude Code for RL engineering Claude Code for RL engineering" + }, + { + "type": "text", + "text": { + "content": "Claude Code for RL engineering Claude Code for RL engineering" + }, + "annotations": {}, + "plain_text": "Claude Code for RL engineering Claude Code for RL engineering" + } + ], + [ + { + "type": "text", + "text": { + "content": "19 19" + }, + "annotations": {}, + "plain_text": "19 19" + }, + { + "type": "text", + "text": { + "content": "19 19" + }, + "annotations": {}, + "plain_text": "19 19" + } + ] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyebfnn8j33t1x23258x", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.272796Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 2 + } + }, + "table_row": { + "cells": [ + [], + [ + { + "type": "text", + "text": { + "content": "Claude Code for legal Claude Code for legal" + }, + "annotations": {}, + "plain_text": "Claude Code for legal Claude Code for legal" + }, + { + "type": "text", + "text": { + "content": "Claude Code for legal Claude Code for legal" + }, + "annotations": {}, + "plain_text": "Claude Code for legal Claude Code for legal" + } + ], + [ + { + "type": "text", + "text": { + "content": "21 21" + }, + "annotations": {}, + "plain_text": "21 21" + }, + { + "type": "text", + "text": { + "content": "21 21" + }, + "annotations": {}, + "plain_text": "21 21" + } + ] + ] + } + } + ] + }, + { + "object": "block", + "id": "bk_01jxwgvyeeffhssnnbhvg1cb98", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.279373Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for data infrastructure " + }, + "annotations": {}, + "plain_text": " Claude Code for data infrastructure " + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for data infrastructure" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyefep2b15ssn8y8t6yn", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.279559Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Data Infrastructure team organizes all business data for teams across the company. They use Claude Code for automating routine data engineering tasks, troubleshooting complex infrastructure issues, and creating documented workflows for technical and non-technical team members to access and manipulate data independently. The Data Infrastructure team organizes all business data for teams across the company. They use Claude Code for automating routine data engineering tasks, troubleshooting complex infrastructureissues,and creating documented workflows for technical and non-technical team members to access and manipulate data independently." + }, + "annotations": {}, + "plain_text": "The Data Infrastructure team organizes all business data for teams across the company. They use Claude Code for automating routine data engineering tasks, troubleshooting complex infrastructure issues, and creating documented workflows for technical and non-technical team members to access and manipulate data independently. The Data Infrastructure team organizes all business data for teams across the company. They use Claude Code for automating routine data engineering tasks, troubleshooting complex infrastructureissues,and creating documented workflows for technical and non-technical team members to access and manipulate data independently." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyegfbn8nkb311794dck", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.279789Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases " + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyehecbb2bv3jtnm9bzx", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.280023Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Kubernetes debugging with screenshots " + }, + "annotations": {}, + "plain_text": "Kubernetes debugging with screenshots " + }, + { + "type": "text", + "text": { + "content": "Kubernetes debugging with screenshots" + }, + "annotations": { + "bold": true + }, + "plain_text": "Kubernetes debugging with screenshots" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyejetjvzhv48cypxfby", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.280223Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When Kubernetes clusters went down and weren't scheduling new pods, the team used Claude Code to diagnose the issue. They fed screenshots of dashboards into Claude Code, which guided them through Google Cloud's UI menu by menu until they found a warning indicating pod IP address exhaustion. Claude Code then provided the exact commands to create a new IP pool and add it to the cluster, bypassing the need to involve networking specialists. When Kubernetes clusters went down and weren't scheduling new pods, the team used Claude Code to diagnose the issue. They fed screenshots of dashboards into Claude Code, which guided them through Google Cloud's UI menu by menu until they found a warning indicating pod IP address exhaustion. Claude Code then provided the exact commands to create a new IP pool and add it to the cluster, bypassing the need to involve networking specialists." + }, + "annotations": {}, + "plain_text": "When Kubernetes clusters went down and weren't scheduling new pods, the team used Claude Code to diagnose the issue. They fed screenshots of dashboards into Claude Code, which guided them through Google Cloud's UI menu by menu until they found a warning indicating pod IP address exhaustion. Claude Code then provided the exact commands to create a new IP pool and add it to the cluster, bypassing the need to involve networking specialists. When Kubernetes clusters went down and weren't scheduling new pods, the team used Claude Code to diagnose the issue. They fed screenshots of dashboards into Claude Code, which guided them through Google Cloud's UI menu by menu until they found a warning indicating pod IP address exhaustion. Claude Code then provided the exact commands to create a new IP pool and add it to the cluster, bypassing the need to involve networking specialists." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyekenwss0qje3gtwfd5", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.280478Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Plain text workflows for finance team " + }, + "annotations": {}, + "plain_text": "Plain text workflows for finance team " + }, + { + "type": "text", + "text": { + "content": "Plain text workflows for finance team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Plain text workflows for finance team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeme7pa4bw09tcqg1vp", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.280666Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team showed finance team members how to write plain text files describing their data workflows, then load them into Claude Code to get fully automated execution. Employees with no coding experience could describe steps like \"query this dashboard, get information, run these queries, produce Excel output,\" and Claude Code would execute the entire workflow, including asking for required inputs like dates. The team showed finance team members how to write plain text files describing their data workflows, then load them into Claude Code to get fully automated execution. Employees with no coding experience could describe steps like \"query this dashboard, get information, run these queries, produce Excel output,\" and Claude Code would execute the entire workflow, including asking for required inputs like dates." + }, + "annotations": {}, + "plain_text": "The team showed finance team members how to write plain text files describing their data workflows, then load them into Claude Code to get fully automated execution. Employees with no coding experience could describe steps like \"query this dashboard, get information, run these queries, produce Excel output,\" and Claude Code would execute the entire workflow, including asking for required inputs like dates. The team showed finance team members how to write plain text files describing their data workflows, then load them into Claude Code to get fully automated execution. Employees with no coding experience could describe steps like \"query this dashboard, get information, run these queries, produce Excel output,\" and Claude Code would execute the entire workflow, including asking for required inputs like dates." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyenepavwcycrzz4hqyr", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.280887Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Codebase navigation for new hires " + }, + "annotations": {}, + "plain_text": "Codebase navigation for new hires " + }, + { + "type": "text", + "text": { + "content": "Codebase navigation for new hires" + }, + "annotations": { + "bold": true + }, + "plain_text": "Codebase navigation for new hires" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyepehvrp0drr82e1rh8", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.281075Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When new data scientists join the team, they're directed to use Claude Code to navigate their massive codebase. Claude Code reads their Claude.md files (documentation), identifies relevant files for specific tasks, explains data pipeline dependencies, and helps newcomers understand which upstream sources feed into dashboards. This replaces traditional data catalogs and discoverability tools. When new data scientists join the team, they're directed to use Claude Code to navigate their massive codebase. Claude Code reads their Claude.md files (documentation), identifies relevant files for specific tasks, explains data pipeline dependencies, and helps newcomers understand which upstream sources feed into dashboards. This replaces traditional data catalogs and discoverability tools." + }, + "annotations": {}, + "plain_text": "When new data scientists join the team, they're directed to use Claude Code to navigate their massive codebase. Claude Code reads their Claude.md files (documentation), identifies relevant files for specific tasks, explains data pipeline dependencies, and helps newcomers understand which upstream sources feed into dashboards. This replaces traditional data catalogs and discoverability tools. When new data scientists join the team, they're directed to use Claude Code to navigate their massive codebase. Claude Code reads their Claude.md files (documentation), identifies relevant files for specific tasks, explains data pipeline dependencies, and helps newcomers understand which upstream sources feed into dashboards. This replaces traditional data catalogs and discoverability tools." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeqfcbsny75cf8awqwg", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.281298Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "End-of-session documentation updates " + }, + "annotations": {}, + "plain_text": "End-of-session documentation updates " + }, + { + "type": "text", + "text": { + "content": "End-of-session documentation updates" + }, + "annotations": { + "bold": true + }, + "plain_text": "End-of-session documentation updates" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeredvv3ezyjyctv0zx", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.281465Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team asks Claude Code to summarize completed work sessions and suggest improvements at the end of each task. This creates a continuous improvement loop where Claude Code helps refine the Claude.md documentation and workflow instructions based on actual usage, making subsequent iterations more effective. The team asks Claude Code to summarize completed work sessions and suggest improvements at the end of each task. This creates a continuous improvement loop where Claude Code helps refine the Claude.md documentation and workflow instructions based on actual usage, making subsequent iterations more effective." + }, + "annotations": {}, + "plain_text": "The team asks Claude Code to summarize completed work sessions and suggest improvements at the end of each task. This creates a continuous improvement loop where Claude Code helps refine the Claude.md documentation and workflow instructions based on actual usage, making subsequent iterations more effective. The team asks Claude Code to summarize completed work sessions and suggest improvements at the end of each task. This creates a continuous improvement loop where Claude Code helps refine the Claude.md documentation and workflow instructions based on actual usage, making subsequent iterations more effective." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyese65vk0z36b571r6p", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.281684Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Parallel task management across multiple instances " + }, + "annotations": {}, + "plain_text": "Parallel task management across multiple instances " + }, + { + "type": "text", + "text": { + "content": "Parallel task management across multiple instances" + }, + "annotations": { + "bold": true + }, + "plain_text": "Parallel task management across multiple instances" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyetewarwb6x245a9g02", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.281858Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 3 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When working on long-running data tasks, they open multiple instances of Claude Code in different repositories for different projects. Each instance maintains full context, so when they switch back after hours or days, Claude Code remembers exactly what they were doing and where they left off, enabling true parallel workflow management without context loss. When working on long-running data tasks, they open multiple instances of Claude Code in different repositories for different projects. Each instance maintains full context, so when they switch back after hours or days, Claude Code remembers exactly what they were doing and where they left off, enabling true parallel workflow management without context loss." + }, + "annotations": {}, + "plain_text": "When working on long-running data tasks, they open multiple instances of Claude Code in different repositories for different projects. Each instance maintains full context, so when they switch back after hours or days, Claude Code remembers exactly what they were doing and where they left off, enabling true parallel workflow management without context loss. When working on long-running data tasks, they open multiple instances of Claude Code in different repositories for different projects. Each instance maintains full context, so when they switch back after hours or days, Claude Code remembers exactly what they were doing and where they left off, enabling true parallel workflow management without context loss." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyewe2wsxxa3fj6bgcvv", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.286428Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure " + }, + "annotations": {}, + "plain_text": "Claude Code for data infrastructure " + }, + { + "type": "text", + "text": { + "content": "Claude Code for data infrastructure" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for data infrastructure" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyexe5bbp8jcy5jq0r0z", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.286665Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeyfen9gjdsp994qdv7", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.286881Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Resolved infrastructure problems without specialized expertise " + }, + "annotations": {}, + "plain_text": "Team impact Resolved infrastructure problems without specialized expertise " + }, + { + "type": "text", + "text": { + "content": "Resolved infrastructure problems without specialized expertise" + }, + "annotations": { + "bold": true + }, + "plain_text": "Resolved infrastructure problems without specialized expertise" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyeze7ns31zwynbvb7b1", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.287054Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Resolved Kubernetes cluster issues that would normally require pulling in systems or networking team members, using Claude Code to diagnose problems and provide exact fixes. Resolved Kubernetes cluster issues that would normally require pulling in systems or networking team members, using Claude Code to diagnose problems and provide exact fixes." + }, + "annotations": {}, + "plain_text": "Resolved Kubernetes cluster issues that would normally require pulling in systems or networking team members, using Claude Code to diagnose problems and provide exact fixes. Resolved Kubernetes cluster issues that would normally require pulling in systems or networking team members, using Claude Code to diagnose problems and provide exact fixes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf0efz8w4awb7q0mrne", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.287288Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Accelerated onboarding " + }, + "annotations": {}, + "plain_text": "Accelerated onboarding " + }, + { + "type": "text", + "text": { + "content": "Accelerated onboarding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Accelerated onboarding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf1fyyb9ak2vm4ajsty", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.287426Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "New data analysts and team members can quickly understand complex systems and contribute meaningfully without extensive guidance. New data analysts and team members can quickly understand complex systems and contribute meaningfully without extensive guidance." + }, + "annotations": {}, + "plain_text": "New data analysts and team members can quickly understand complex systems and contribute meaningfully without extensive guidance. New data analysts and team members can quickly understand complex systems and contribute meaningfully without extensive guidance." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf2es6r0wmrcvjh3gst", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.287640Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enhanced support workflow " + }, + "annotations": {}, + "plain_text": "Enhanced support workflow " + }, + { + "type": "text", + "text": { + "content": "Enhanced support workflow" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enhanced support workflow" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf3fv7a4cjyf0n34dnm", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.287777Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Can process much larger data volumes and identify anomalies (like monitoring 200 dashboards) that would be impossible for humans to review manually. Can process much larger data volumes and identify anomalies (like monitoring 200 dashboards) that would be impossible for humans to review manually." + }, + "annotations": {}, + "plain_text": "Can process much larger data volumes and identify anomalies (like monitoring 200 dashboards) that would be impossible for humans to review manually. Can process much larger data volumes and identify anomalies (like monitoring 200 dashboards) that would be impossible for humans to review manually." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf4fgqrnkvk24c0y43a", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.287993Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enabled cross-team self-service " + }, + "annotations": {}, + "plain_text": "Enabled cross-team self-service " + }, + { + "type": "text", + "text": { + "content": "Enabled cross-team self-service" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enabled cross-team self-service" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf5f1c9dkdyz9416e43", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.288131Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Finance teams with no coding experience can now execute complex data workflows independently. Finance teams with no coding experience can now execute complex data workflows independently." + }, + "annotations": {}, + "plain_text": "Finance teams with no coding experience can now execute complex data workflows independently. Finance teams with no coding experience can now execute complex data workflows independently." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf6fy5bmx819z28m84h", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.288371Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Data Infrastructure team " + }, + "annotations": {}, + "plain_text": "Top tips from the Data Infrastructure team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Data Infrastructure team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Data Infrastructure team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf7e3jvsa17m3qe4hwq", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.288591Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Write detailed Claude.md files " + }, + "annotations": {}, + "plain_text": "Write detailed Claude.md files " + }, + { + "type": "text", + "text": { + "content": "Write detailed Claude.md files" + }, + "annotations": { + "bold": true + }, + "plain_text": "Write detailed Claude.md files" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf8e1jvswtmet1mp2ff", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.288746Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The better you document your workflows, tools, and expectations in Claude.md files, the better Claude Code performs. This made Claude Code excel at routine tasks like setting up new data pipelines when you have existing patterns. The better you document your workflows, tools, and expectations in Claude.md files, the better Claude Code performs. This made Claude Code excel at routine tasks like setting up new data pipelines when you have existing patterns." + }, + "annotations": {}, + "plain_text": "The better you document your workflows, tools, and expectations in Claude.md files, the better Claude Code performs. This made Claude Code excel at routine tasks like setting up new data pipelines when you have existing patterns. The better you document your workflows, tools, and expectations in Claude.md files, the better Claude Code performs. This made Claude Code excel at routine tasks like setting up new data pipelines when you have existing patterns." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyf9fjgvygws0fje6y8d", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.288965Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use MCP servers instead of CLI for sensitive data " + }, + "annotations": {}, + "plain_text": "Use MCP servers instead of CLI for sensitive data " + }, + { + "type": "text", + "text": { + "content": "Use MCP servers instead of CLI for sensitive data" + }, + "annotations": { + "bold": true + }, + "plain_text": "Use MCP servers instead of CLI for sensitive data" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfaf6brjfy4764wvg52", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.289126Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They recommend using MCP servers rather than the BigQuery CLI to maintain better security control over what Claude Code can access, especially for handling sensitive data that requires logging or has potential privacy concerns. They recommend using MCP servers rather than the BigQuery CLI to maintain better security control over what Claude Code can access, especially for handling sensitive data that requires logging or has potential privacy concerns." + }, + "annotations": {}, + "plain_text": "They recommend using MCP servers rather than the BigQuery CLI to maintain better security control over what Claude Code can access, especially for handling sensitive data that requires logging or has potential privacy concerns. They recommend using MCP servers rather than the BigQuery CLI to maintain better security control over what Claude Code can access, especially for handling sensitive data that requires logging or has potential privacy concerns." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfbf2wstehxnse73x4f", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.289346Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Share team usage sessions " + }, + "annotations": {}, + "plain_text": "Share team usage sessions " + }, + { + "type": "text", + "text": { + "content": "Share team usage sessions" + }, + "annotations": { + "bold": true + }, + "plain_text": "Share team usage sessions" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfcfbvtt3qx8mzw0pc6", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.289497Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 4 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team held sessions where members demonstrated their Claude Code workflows to each other. This helped spread best practices and showed different ways to use the tool they might not have discovered on their own. The team held sessions where members demonstrated their Claude Code workflows to each other. This helped spread best practices and showed different ways to use the tool they might not have discovered on their own." + }, + "annotations": {}, + "plain_text": "The team held sessions where members demonstrated their Claude Code workflows to each other. This helped spread best practices and showed different ways to use the tool they might not have discovered on their own. The team held sessions where members demonstrated their Claude Code workflows to each other. This helped spread best practices and showed different ways to use the tool they might not have discovered on their own." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfee0kt88bcn3s7qre9", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.294383Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for product development " + }, + "annotations": {}, + "plain_text": " Claude Code for product development " + }, + { + "type": "text", + "text": { + "content": "Claude Code for product development" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for product development" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyffe3svtwg7as2800nm", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.294544Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Claude Code team uses their own product to build updates to Claude Code, expanding the product's enterprise capabilities and agentic loop functionalities. The Claude Code team uses their own product to build updates to Claude Code, expanding the product's enterprise capabilities and agentic loop functionalities." + }, + "annotations": {}, + "plain_text": "The Claude Code team uses their own product to build updates to Claude Code, expanding the product's enterprise capabilities and agentic loop functionalities. The Claude Code team uses their own product to build updates to Claude Code, expanding the product's enterprise capabilities and agentic loop functionalities." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfge9mvfxvtwjqkavrq", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.294860Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases " + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfhfk3ar98w2647e6nw", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.295100Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Fast prototyping with auto-accept mode " + }, + "annotations": {}, + "plain_text": "Fast prototyping with auto-accept mode " + }, + { + "type": "text", + "text": { + "content": "Fast prototyping with auto-accept mode" + }, + "annotations": { + "bold": true + }, + "plain_text": "Fast prototyping with auto-accept mode" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfjeafs7cz222tfd7zc", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.295311Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Engineers use Claude Code for rapid prototyping by enabling \"autoaccept mode\" (shift+tab) and setting up autonomous loops where Claude writes code, runs tests, and iterates continuously. They give Claude abstract problems they're unfamiliar with, let it work autonomously, then review the 80% complete solution before taking over for final refinements. Teams emphasize starting from a clean git state and committing checkpoints regularly so they can easily revert any incorrect changes if Claude goes off track. Engineers use Claude Code for rapid prototyping by enabling \"autoaccept mode\" (shift+tab) and setting up autonomous loops where Claude writes code, runs tests, and iterates continuously. They give Claude abstract problems they're unfamiliar with, let it work autonomously, then review the 80% complete solution before taking over for final refinements. Teams emphasize starting from a clean git state and committing checkpoints regularly so they can easily revert any incorrect changes if Claude goes off track." + }, + "annotations": {}, + "plain_text": "Engineers use Claude Code for rapid prototyping by enabling \"autoaccept mode\" (shift+tab) and setting up autonomous loops where Claude writes code, runs tests, and iterates continuously. They give Claude abstract problems they're unfamiliar with, let it work autonomously, then review the 80% complete solution before taking over for final refinements. Teams emphasize starting from a clean git state and committing checkpoints regularly so they can easily revert any incorrect changes if Claude goes off track. Engineers use Claude Code for rapid prototyping by enabling \"autoaccept mode\" (shift+tab) and setting up autonomous loops where Claude writes code, runs tests, and iterates continuously. They give Claude abstract problems they're unfamiliar with, let it work autonomously, then review the 80% complete solution before taking over for final refinements. Teams emphasize starting from a clean git state and committing checkpoints regularly so they can easily revert any incorrect changes if Claude goes off track." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfkejhbb5ny4ywn22ma", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.295545Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Synchronous coding for core features " + }, + "annotations": {}, + "plain_text": "Synchronous coding for core features " + }, + { + "type": "text", + "text": { + "content": "Synchronous coding for core features" + }, + "annotations": { + "bold": true + }, + "plain_text": "Synchronous coding for core features" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfmew79gyj8t85fzf5f", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.295725Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "For more critical features touching the application's business logic, the team works synchronously with Claude Code, giving detailed prompts with specific implementation instructions. They monitor the process in real-time to ensure code quality, style guide compliance, and proper architecture while letting Claude handle the repetitive coding work. For more critical features touching the application's business logic, the team works synchronously with Claude Code, giving detailed prompts with specific implementation instructions. They monitor the process in real-time to ensure code quality, style guide compliance, and proper architecture while letting Claude handle the repetitive coding work." + }, + "annotations": {}, + "plain_text": "For more critical features touching the application's business logic, the team works synchronously with Claude Code, giving detailed prompts with specific implementation instructions. They monitor the process in real-time to ensure code quality, style guide compliance, and proper architecture while letting Claude handle the repetitive coding work. For more critical features touching the application's business logic, the team works synchronously with Claude Code, giving detailed prompts with specific implementation instructions. They monitor the process in real-time to ensure code quality, style guide compliance, and proper architecture while letting Claude handle the repetitive coding work." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfnfyntv9p33d1kn2rx", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.295944Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Building Vim mode " + }, + "annotations": {}, + "plain_text": "Building Vim mode " + }, + { + "type": "text", + "text": { + "content": "Building Vim mode" + }, + "annotations": { + "bold": true + }, + "plain_text": "Building Vim mode" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfpfrtbz0mp4yjw4sas", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.296122Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "One of their most successful async projects was implementing Vim key bindings for Claude Code. They asked Claude to build the entire feature (despite it not being a priority), and roughly 70% of the final implementation came from Claude's autonomous work, requiring only a few iterations to complete. One of their most successful async projects was implementing Vim key bindings for Claude Code. They asked Claude to build the entire feature (despite it not being a priority), and roughly 70% of the final implementation came from Claude's autonomous work, requiring only a few iterations to complete." + }, + "annotations": {}, + "plain_text": "One of their most successful async projects was implementing Vim key bindings for Claude Code. They asked Claude to build the entire feature (despite it not being a priority), and roughly 70% of the final implementation came from Claude's autonomous work, requiring only a few iterations to complete. One of their most successful async projects was implementing Vim key bindings for Claude Code. They asked Claude to build the entire feature (despite it not being a priority), and roughly 70% of the final implementation came from Claude's autonomous work, requiring only a few iterations to complete." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfqf0prdg607b8za668", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.296362Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Test generation and bug fixes " + }, + "annotations": {}, + "plain_text": "Test generation and bug fixes " + }, + { + "type": "text", + "text": { + "content": "Test generation and bug fixes" + }, + "annotations": { + "bold": true + }, + "plain_text": "Test generation and bug fixes" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfrfcmve090kb3r2003", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.296530Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They use Claude Code to write comprehensive tests after implementing features and handle simple bug fixes identified in pull request reviews. They also leverage GitHub Actions integration to have Claude automatically address Pull Request comments like formatting issues or function renaming. They use Claude Code to write comprehensive tests after implementing features and handle simple bug fixes identified in pull request reviews. They also leverage GitHub Actions integration to have Claude automatically address Pull Request comments like formatting issues or function renaming." + }, + "annotations": {}, + "plain_text": "They use Claude Code to write comprehensive tests after implementing features and handle simple bug fixes identified in pull request reviews. They also leverage GitHub Actions integration to have Claude automatically address Pull Request comments like formatting issues or function renaming. They use Claude Code to write comprehensive tests after implementing features and handle simple bug fixes identified in pull request reviews. They also leverage GitHub Actions integration to have Claude automatically address Pull Request comments like formatting issues or function renaming." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfsfprtdzk41hjw092n", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.296743Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Codebase exploration " + }, + "annotations": {}, + "plain_text": "Codebase exploration " + }, + { + "type": "text", + "text": { + "content": "Codebase exploration" + }, + "annotations": { + "bold": true + }, + "plain_text": "Codebase exploration" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyftecxrmz24twc3y6ad", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.296907Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 5 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When working with unfamiliar codebases (like the monorepo or API side), the team uses Claude Code to quickly understand how systems work. Instead of waiting for Slack responses, they ask Claude directly for explanations and code references, saving significant time in context switching. When working with unfamiliar codebases (like the monorepo or API side), the team uses Claude Code to quickly understand how systems work. Instead of waiting for Slack responses, they ask Claude directly for explanations and code references, saving significant time in context switching." + }, + "annotations": {}, + "plain_text": "When working with unfamiliar codebases (like the monorepo or API side), the team uses Claude Code to quickly understand how systems work. Instead of waiting for Slack responses, they ask Claude directly for explanations and code references, saving significant time in context switching. When working with unfamiliar codebases (like the monorepo or API side), the team uses Claude Code to quickly understand how systems work. Instead of waiting for Slack responses, they ask Claude directly for explanations and code references, saving significant time in context switching." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfwfvavyphzbpj334ab", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.301387Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for product development " + }, + "annotations": {}, + "plain_text": "Claude Code for product development " + }, + { + "type": "text", + "text": { + "content": "Claude Code for product development" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for product development" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfxebc9z93v4xawp21j", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.301627Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfye1mbakkqmnp7018v", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.301837Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Faster feature implementation " + }, + "annotations": {}, + "plain_text": "Team impact Faster feature implementation " + }, + { + "type": "text", + "text": { + "content": "Faster feature implementation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Faster feature implementation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyfzffsvnfbhvkc4xr4z", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.301969Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Successfully implemented complex features like Vim mode with 70% of code written autonomously by Claude. Successfully implemented complex features like Vim mode with 70% of code written autonomously by Claude." + }, + "annotations": {}, + "plain_text": "Successfully implemented complex features like Vim mode with 70% of code written autonomously by Claude. Successfully implemented complex features like Vim mode with 70% of code written autonomously by Claude." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg0ezcsqg2zj2f5wrek", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.302194Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Improved development velocity " + }, + "annotations": {}, + "plain_text": "Improved development velocity " + }, + { + "type": "text", + "text": { + "content": "Improved development velocity" + }, + "annotations": { + "bold": true + }, + "plain_text": "Improved development velocity" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg1fgw9f3kc51x8f9ck", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.302332Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Can rapidly prototype features and iterate on ideas without getting bogged down in implementation details. Can rapidly prototype features and iterate on ideas without getting bogged down in implementation details." + }, + "annotations": {}, + "plain_text": "Can rapidly prototype features and iterate on ideas without getting bogged down in implementation details. Can rapidly prototype features and iterate on ideas without getting bogged down in implementation details." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg2fcva7js0tp954vtx", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.302550Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enhanced code quality through automated testing " + }, + "annotations": {}, + "plain_text": "Enhanced code quality through automated testing " + }, + { + "type": "text", + "text": { + "content": "Enhanced code quality through automated testing" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enhanced code quality through automated testing" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg3fezs6wf1gb1dg33k", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.302682Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude generates comprehensive tests and handles routine bug fixes, maintaining high standards while reducing manual effort. Claude generates comprehensive tests and handles routine bug fixes, maintaining high standards while reducing manual effort." + }, + "annotations": {}, + "plain_text": "Claude generates comprehensive tests and handles routine bug fixes, maintaining high standards while reducing manual effort. Claude generates comprehensive tests and handles routine bug fixes, maintaining high standards while reducing manual effort." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg4fdfvrfsktff1epf5", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.302894Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Better codebase exploration " + }, + "annotations": {}, + "plain_text": "Better codebase exploration " + }, + { + "type": "text", + "text": { + "content": "Better codebase exploration" + }, + "annotations": { + "bold": true + }, + "plain_text": "Better codebase exploration" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg5e70br50m2ber5z8y", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.303033Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team members can quickly understand unfamiliar parts of the monorepo without waiting for colleague responses. Team members can quickly understand unfamiliar parts of the monorepo without waiting for colleague responses." + }, + "annotations": {}, + "plain_text": "Team members can quickly understand unfamiliar parts of the monorepo without waiting for colleague responses. Team members can quickly understand unfamiliar parts of the monorepo without waiting for colleague responses." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg6fw18d8j8dsrrvxjx", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.304646Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Claude Code team " + }, + "annotations": {}, + "plain_text": "Top tips from the Claude Code team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Claude Code team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Claude Code team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg7fwp8srmpc6sdc0aj", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.304881Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Create self-sufficient loops " + }, + "annotations": {}, + "plain_text": "Create self-sufficient loops " + }, + { + "type": "text", + "text": { + "content": "Create self-sufficient loops" + }, + "annotations": { + "bold": true + }, + "plain_text": "Create self-sufficient loops" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg8fy6bj2hkkhcac6t3", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.305055Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Set up Claude to verify its own work by running builds, tests, and lints automatically. This allows Claude to work longer autonomously and catch its own mistakes, especially effective when you ask Claude to generate tests before writing code. Set up Claude to verify its own work by running builds, tests, and lints automatically. This allows Claude to work longer autonomously and catch its own mistakes, especially effective when you ask Claude to generate tests before writing code." + }, + "annotations": {}, + "plain_text": "Set up Claude to verify its own work by running builds, tests, and lints automatically. This allows Claude to work longer autonomously and catch its own mistakes, especially effective when you ask Claude to generate tests before writing code. Set up Claude to verify its own work by running builds, tests, and lints automatically. This allows Claude to work longer autonomously and catch its own mistakes, especially effective when you ask Claude to generate tests before writing code." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyg9fz4sjdg23543m7kc", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.305277Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Develop task classification intuition " + }, + "annotations": {}, + "plain_text": "Develop task classification intuition " + }, + { + "type": "text", + "text": { + "content": "Develop task classification intuition" + }, + "annotations": { + "bold": true + }, + "plain_text": "Develop task classification intuition" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygaee7bf03zs5bbkv13", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.305434Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Learn to distinguish between tasks that work well asynchronously (peripheral features, prototyping) versus those needing synchronous supervision (core business logic, critical fixes). Abstract tasks on the product's edges can be handled with \"auto-accept mode,\" while core functionality requires closer oversight. Learn to distinguish between tasks that work well asynchronously (peripheral features, prototyping) versus those needing synchronous supervision (core business logic, critical fixes). Abstract tasks on the product's edges can be handled with \"auto-accept mode,\" while core functionality requires closer oversight." + }, + "annotations": {}, + "plain_text": "Learn to distinguish between tasks that work well asynchronously (peripheral features, prototyping) versus those needing synchronous supervision (core business logic, critical fixes). Abstract tasks on the product's edges can be handled with \"auto-accept mode,\" while core functionality requires closer oversight. Learn to distinguish between tasks that work well asynchronously (peripheral features, prototyping) versus those needing synchronous supervision (core business logic, critical fixes). Abstract tasks on the product's edges can be handled with \"auto-accept mode,\" while core functionality requires closer oversight." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygbf5ksy8q2h9w31382", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.305646Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Form clear, detailed prompts " + }, + "annotations": {}, + "plain_text": "Form clear, detailed prompts " + }, + { + "type": "text", + "text": { + "content": "Form clear, detailed prompts" + }, + "annotations": { + "bold": true + }, + "plain_text": "Form clear, detailed prompts" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygcf4vv7w13j3t1jbf5", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.305803Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 6 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When components have similar names or functions, be extremely specific in your requests. The better and more detailed your prompt, the more you can trust Claude to work independently without unexpected changes to the wrong parts of the codebase. When components have similar names or functions, be extremely specific in your requests. The better and more detailed your prompt, the more you can trust Claude to work independently without unexpected changes to the wrong parts of the code base." + }, + "annotations": {}, + "plain_text": "When components have similar names or functions, be extremely specific in your requests. The better and more detailed your prompt, the more you can trust Claude to work independently without unexpected changes to the wrong parts of the codebase. When components have similar names or functions, be extremely specific in your requests. The better and more detailed your prompt, the more you can trust Claude to work independently without unexpected changes to the wrong parts of the code base." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygeecjrmyh8djv61ybc", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.310872Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for security engineering " + }, + "annotations": {}, + "plain_text": " Claude Code for security engineering " + }, + { + "type": "text", + "text": { + "content": "Claude Code for security" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for security" + }, + { + "type": "text", + "text": { + "content": " ■ ■ " + }, + "annotations": {}, + "plain_text": " ■ ■ " + }, + { + "type": "text", + "text": { + "content": "eng1neer1ng" + }, + "annotations": { + "bold": true + }, + "plain_text": "eng1neer1ng" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygffxtt97jfsmgta2vc", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.311058Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Security Engineering team focuses on securing the software development lifecycle, supply chain security, and development environment security. They use Claude Code extensively for writing and debugging code. The Security Engineering team focuses on securing the software development lifecycle, supply chain security, and development environment security. They use Claude Code extensively for writing and debugging code." + }, + "annotations": {}, + "plain_text": "The Security Engineering team focuses on securing the software development lifecycle, supply chain security, and development environment security. They use Claude Code extensively for writing and debugging code. The Security Engineering team focuses on securing the software development lifecycle, supply chain security, and development environment security. They use Claude Code extensively for writing and debugging code." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyggehb82qem6fdx1amz", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.311285Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases " + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyghf608abbzk3sqsf8d", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.311508Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Complex infrastructure debugging " + }, + "annotations": {}, + "plain_text": "Complex infrastructure debugging " + }, + { + "type": "text", + "text": { + "content": "Complex infrastructure debugging" + }, + "annotations": { + "bold": true + }, + "plain_text": "Complex infrastructure debugging" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygjfgcb31w25ybky1k9", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.311680Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When working on incidents, they feed Claude Code stack traces and documentation, asking it to trace control flow through the codebase. This significantly reduces time-to-resolution for production issues, allowing them to understand problems that would normally take 10-15 minutes of manual code scanning in about 5 minutes. When working on incidents, they feed Claude Code stack traces and documentation, asking it to trace control flow through the code base. This significantly reduces time-to-resolution for production issues, allowing them to understand problems that would normally take 10-15 minutes of manual code scanning in about 5 minutes." + }, + "annotations": {}, + "plain_text": "When working on incidents, they feed Claude Code stack traces and documentation, asking it to trace control flow through the codebase. This significantly reduces time-to-resolution for production issues, allowing them to understand problems that would normally take 10-15 minutes of manual code scanning in about 5 minutes. When working on incidents, they feed Claude Code stack traces and documentation, asking it to trace control flow through the code base. This significantly reduces time-to-resolution for production issues, allowing them to understand problems that would normally take 10-15 minutes of manual code scanning in about 5 minutes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygkfw18e6ky0anzc78d", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.311899Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Terraform code review and analysis " + }, + "annotations": {}, + "plain_text": "Terraform code review and analysis " + }, + { + "type": "text", + "text": { + "content": "Terraform code review and analysis" + }, + "annotations": { + "bold": true + }, + "plain_text": "Terraform code review and analysis" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygmfcmr9rj7fggp7m5w", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.312079Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "For infrastructure changes requiring security approval, they copy Terraform plans into Claude Code to ask \"what's this going to do? Am I going to regret this?\" This creates tighter feedback loops and makes it easier for the security team to quickly review and approve infrastructure changes, reducing bottlenecks in the development process. For infrastructure changes requiring security approval, they copy Terraform plans into Claude Code to ask \"what's this going to do? Am I going to regret this?\" This creates tighter feedback loops and makes it easier for the security team to quickly review and approve infrastructure changes, reducing bottlenecks in the development process." + }, + "annotations": {}, + "plain_text": "For infrastructure changes requiring security approval, they copy Terraform plans into Claude Code to ask \"what's this going to do? Am I going to regret this?\" This creates tighter feedback loops and makes it easier for the security team to quickly review and approve infrastructure changes, reducing bottlenecks in the development process. For infrastructure changes requiring security approval, they copy Terraform plans into Claude Code to ask \"what's this going to do? Am I going to regret this?\" This creates tighter feedback loops and makes it easier for the security team to quickly review and approve infrastructure changes, reducing bottlenecks in the development process." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygnecbv6ejg9yyhhm1b", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.312321Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Documentation synthesis and runbooks " + }, + "annotations": {}, + "plain_text": "Documentation synthesis and runbooks " + }, + { + "type": "text", + "text": { + "content": "Documentation synthesis and runbooks" + }, + "annotations": { + "bold": true + }, + "plain_text": "Documentation synthesis and runbooks" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygpf1evbrp7987kv7jn", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.312486Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They have Claude Code ingest multiple documentation sources and create markdown runbooks, troubleshooting guides, and overviews. They use these condensed documents as context for debugging real issues, creating a more efficient workflow than searching through full knowledge bases. They have Claude Code ingest multiple documentation sources and create markdown run books, troubleshooting guides, and overviews. They use these condensed documents as context for debugging real issues, creating a more efficient workflow than searching through full knowledge bases." + }, + "annotations": {}, + "plain_text": "They have Claude Code ingest multiple documentation sources and create markdown runbooks, troubleshooting guides, and overviews. They use these condensed documents as context for debugging real issues, creating a more efficient workflow than searching through full knowledge bases. They have Claude Code ingest multiple documentation sources and create markdown run books, troubleshooting guides, and overviews. They use these condensed documents as context for debugging real issues, creating a more efficient workflow than searching through full knowledge bases." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygqf1n92rhx00am626m", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.312707Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Test-driven development workflow " + }, + "annotations": {}, + "plain_text": "Test-driven development workflow " + }, + { + "type": "text", + "text": { + "content": "Test-driven development workflow" + }, + "annotations": { + "bold": true + }, + "plain_text": "Test-driven development workflow" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygrff7vy80mah0t3gqv", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.312879Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of their previous \"design doc → janky code → refactor → give up on tests\" pattern, they now ask Claude Code for pseudocode, guide it through test-driven development, and periodically check in to steer it when stuck, resulting in more reliable and testable code. Instead of their previous \"design doc - janky code - refactor - give up on tests\" pattern, they now ask Claude Code for pseudocode, guide it through test-driven development, and periodically check in to steer it when stuck, resulting in more reliable and testable code." + }, + "annotations": {}, + "plain_text": "Instead of their previous \"design doc → janky code → refactor → give up on tests\" pattern, they now ask Claude Code for pseudocode, guide it through test-driven development, and periodically check in to steer it when stuck, resulting in more reliable and testable code. Instead of their previous \"design doc - janky code - refactor - give up on tests\" pattern, they now ask Claude Code for pseudocode, guide it through test-driven development, and periodically check in to steer it when stuck, resulting in more reliable and testable code." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygsf8ab3a60wqyxkt4n", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.313112Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Context switching and project onboarding " + }, + "annotations": {}, + "plain_text": "Context switching and project onboarding " + }, + { + "type": "text", + "text": { + "content": "Context switching and project onboarding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Context switching and project onboarding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygteva9fzmsrnxrba29", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.313277Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 7 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When contributing to existing projects like \"dependant\" (a web application for security approval workflows), they use Claude Code to write, review, and execute specifications written in markdown and stored in the codebase, enabling meaningful contributions within days instead of weeks. When contributing to existing projects like \"dependant\" (a web application for security approval workflows), they use Claude Code to write, review, and execute specifications written in markdown and stored in the codebase, enabling meaningful contributions within days instead of weeks." + }, + "annotations": {}, + "plain_text": "When contributing to existing projects like \"dependant\" (a web application for security approval workflows), they use Claude Code to write, review, and execute specifications written in markdown and stored in the codebase, enabling meaningful contributions within days instead of weeks. When contributing to existing projects like \"dependant\" (a web application for security approval workflows), they use Claude Code to write, review, and execute specifications written in markdown and stored in the codebase, enabling meaningful contributions within days instead of weeks." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygweg8rnx16d89x8xz9", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.318180Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for security engineering " + }, + "annotations": {}, + "plain_text": "Claude Code for security engineering " + }, + { + "type": "text", + "text": { + "content": "Claude Code for security" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for security" + }, + { + "type": "text", + "text": { + "content": " ■ ■ " + }, + "annotations": {}, + "plain_text": " ■ ■ " + }, + { + "type": "text", + "text": { + "content": "eng1neer1ng" + }, + "annotations": { + "bold": true + }, + "plain_text": "eng1neer1ng" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygxepkagvw5e101p728", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.318429Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygyfw2sbh8frj7dk4v3", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.318641Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Reduced incident resolution time " + }, + "annotations": {}, + "plain_text": "Team impact Reduced incident resolution time " + }, + { + "type": "text", + "text": { + "content": "Reduced incident resolution time" + }, + "annotations": { + "bold": true + }, + "plain_text": "Reduced incident resolution time" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvygzfx286fht5hmdmfv8", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.318776Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Infrastructure debugging that normally takes 10-15 minutes of manual code scanning now takes about 5 minutes. Infrastructure debugging that normally takes 10-15 minutes of manual code scanning now takes about 5 minutes." + }, + "annotations": {}, + "plain_text": "Infrastructure debugging that normally takes 10-15 minutes of manual code scanning now takes about 5 minutes. Infrastructure debugging that normally takes 10-15 minutes of manual code scanning now takes about 5 minutes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh0eyss82zw55f2wfrj", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.318993Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Improved security review cycle " + }, + "annotations": {}, + "plain_text": "Improved security review cycle " + }, + { + "type": "text", + "text": { + "content": "Improved security review cycle" + }, + "annotations": { + "bold": true + }, + "plain_text": "Improved security review cycle" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh1egzv0s2fs7qkc85v", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.319142Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Terraform code reviews for security approval happen much faster, eliminating developer blocks while waiting for security team approval. Terraform code reviews for security approval happen much faster, eliminating developer blocks while waiting for security team approval." + }, + "annotations": {}, + "plain_text": "Terraform code reviews for security approval happen much faster, eliminating developer blocks while waiting for security team approval. Terraform code reviews for security approval happen much faster, eliminating developer blocks while waiting for security team approval." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh2f9w89v76dn8kf2dv", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.319361Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enhanced cross-functional contribution " + }, + "annotations": {}, + "plain_text": "Enhanced cross-functional contribution " + }, + { + "type": "text", + "text": { + "content": "Enhanced cross-functional contribution" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enhanced cross-functional contribution" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh3ec889yzappzbjaej", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.319491Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team members can meaningfully contribute to projects within days instead of weeks of context building. Team members can meaningfully contribute to projects within days instead of weeks of context building." + }, + "annotations": {}, + "plain_text": "Team members can meaningfully contribute to projects within days instead of weeks of context building. Team members can meaningfully contribute to projects within days instead of weeks of context building." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh4e67v4pweg32v6x83", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.319703Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Better documentation workflow " + }, + "annotations": {}, + "plain_text": "Better documentation workflow " + }, + { + "type": "text", + "text": { + "content": "Better documentation workflow" + }, + "annotations": { + "bold": true + }, + "plain_text": "Better documentation workflow" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh5eq6ayv9f1vdf1nhv", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.319834Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Synthesized troubleshooting guides and runbooks from multiple sources create more efficient debugging processes. Synthesized troubleshooting guides and runbooks from multiple sources create more efficient debugging processes." + }, + "annotations": {}, + "plain_text": "Synthesized troubleshooting guides and runbooks from multiple sources create more efficient debugging processes. Synthesized troubleshooting guides and runbooks from multiple sources create more efficient debugging processes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh6fm0btk070pq72vne", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.320058Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Security Engineering team " + }, + "annotations": {}, + "plain_text": "Top tips from the Security Engineering team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Security Engineering team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Security Engineering team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh7fkfaqd6twg7x2d86", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.320294Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use custom slash commands extensively " + }, + "annotations": {}, + "plain_text": "Use custom slash commands extensively " + }, + { + "type": "text", + "text": { + "content": "Use custom slash commands extensively" + }, + "annotations": { + "bold": true + }, + "plain_text": "Use custom slash commands extensively" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh8e588pb00t9pf58gt", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.320449Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Security engineering uses 50% of all custom slash command implementations in the entire monorepo. These custom commands streamline specific workflows and speed up repeated tasks. Security engineering uses 50% of all custom slash command implementations in the entire monorepo. These custom commands streamline specific workflows and speed up repeated tasks." + }, + "annotations": {}, + "plain_text": "Security engineering uses 50% of all custom slash command implementations in the entire monorepo. These custom commands streamline specific workflows and speed up repeated tasks. Security engineering uses 50% of all custom slash command implementations in the entire monorepo. These custom commands streamline specific workflows and speed up repeated tasks." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyh9escstaetnj7ah02t", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.320667Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Let Claude talk first " + }, + "annotations": {}, + "plain_text": "Let Claude talk first " + }, + { + "type": "text", + "text": { + "content": "Let Claude talk first" + }, + "annotations": { + "bold": true + }, + "plain_text": "Let Claude talk first" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhaene9ckh1bbtbwgf7", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.320816Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of asking targeted questions for code snippets, they now tell Claude Code to \"commit your work as you go\" and let it work autonomously with periodic check-ins, resulting in more comprehensive solutions. Instead of asking targeted questions for code snippets, they now tell Claude Code to \"commit your work as you go\" and let it work autonomously with periodic check-ins, resulting in more comprehensive solutions." + }, + "annotations": {}, + "plain_text": "Instead of asking targeted questions for code snippets, they now tell Claude Code to \"commit your work as you go\" and let it work autonomously with periodic check-ins, resulting in more comprehensive solutions. Instead of asking targeted questions for code snippets, they now tell Claude Code to \"commit your work as you go\" and let it work autonomously with periodic check-ins, resulting in more comprehensive solutions." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhbewqb5a4mamy436ke", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.321043Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Leverage it for documentation " + }, + "annotations": {}, + "plain_text": "Leverage it for documentation " + }, + { + "type": "text", + "text": { + "content": "Leverage it for documentation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Leverage it for documentation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhcfw8sfzb314dvrwq5", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.321206Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 8 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Beyond coding, Claude Code excels at synthesizing documentation and creating structured outputs. They provide writing samples and formatting preferences to get documents they can immediately use in Slack, Google Docs, and other tools to avoid interface switching fatigue. Beyond coding, Claude Code excels at synthesizing documentation and creating structured outputs. They provide writing samples and formatting preferences to get documents they can immediately use in Slack, Google Docs, and other tools to avoid interface switching fatigue." + }, + "annotations": {}, + "plain_text": "Beyond coding, Claude Code excels at synthesizing documentation and creating structured outputs. They provide writing samples and formatting preferences to get documents they can immediately use in Slack, Google Docs, and other tools to avoid interface switching fatigue. Beyond coding, Claude Code excels at synthesizing documentation and creating structured outputs. They provide writing samples and formatting preferences to get documents they can immediately use in Slack, Google Docs, and other tools to avoid interface switching fatigue." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyheehb8ceymw5fv7hc0", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.326251Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for inference " + }, + "annotations": {}, + "plain_text": " Claude Code for inference " + }, + { + "type": "text", + "text": { + "content": "Claude Code for inference" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for inference" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhffmk8w5gm19e40hhn", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.326640Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Inference team manages the memory system that stores information while Claude reads your prompt and generates its response. Team members, especially those who are new to machine learning, can use Claude Code extensively to bridge that knowledge gap and accelerate their work. The Inference team manages the memory system that stores information while Claude reads your prompt and generates its response. Team members, especially those who are new to machine learning, can use Claude Code extensively to bridge that knowledge gap and accelerate their work. " + }, + "annotations": {}, + "plain_text": "The Inference team manages the memory system that stores information while Claude reads your prompt and generates its response. Team members, especially those who are new to machine learning, can use Claude Code extensively to bridge that knowledge gap and accelerate their work. The Inference team manages the memory system that stores information while Claude reads your prompt and generates its response. Team members, especially those who are new to machine learning, can use Claude Code extensively to bridge that knowledge gap and accelerate their work. " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhgf02s74mxnjpct0c5", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.326762Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhhegv97m6wbvk1s295", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.326984Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Codebase comprehension and onboarding " + }, + "annotations": {}, + "plain_text": "Codebase comprehension and onboarding " + }, + { + "type": "text", + "text": { + "content": "Codebase comprehension and onboarding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Codebase comprehension and onboarding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhjeeyt1f2xjr0vhp9z", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.327163Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team relies heavily on Claude Code to quickly understand the architecture when joining a complex codebase. Instead of manually searching GitHub repos, they ask Claude to find which files call specific functionalities, getting results in seconds rather than asking colleagues or searching manually. The team relies heavily on Claude Code to quickly understand the architecture when joining a complex codebase. Instead of manually searching GitHub repos, they ask Claude to find which files call specific functionalities, getting results in seconds rather than asking colleagues or searching manually." + }, + "annotations": {}, + "plain_text": "The team relies heavily on Claude Code to quickly understand the architecture when joining a complex codebase. Instead of manually searching GitHub repos, they ask Claude to find which files call specific functionalities, getting results in seconds rather than asking colleagues or searching manually. The team relies heavily on Claude Code to quickly understand the architecture when joining a complex codebase. Instead of manually searching GitHub repos, they ask Claude to find which files call specific functionalities, getting results in seconds rather than asking colleagues or searching manually." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhke2gsdmn5npp55dkr", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.327390Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Unit test generation with edge case coverage " + }, + "annotations": {}, + "plain_text": "Unit test generation with edge case coverage " + }, + { + "type": "text", + "text": { + "content": "Unit test generation with edge case coverage" + }, + "annotations": { + "bold": true + }, + "plain_text": "Unit test generation with edge case coverage" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhmfk282yjh7djxvp5e", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.327550Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "After writing core functionality, they ask Claude to write comprehensive unit tests. Claude automatically includes missed edge cases, completing what would normally take significant mental energy in minutes, acting like a coding assistant they can review. After writing core functionality, they ask Claude to write comprehensive unit tests. Claude automatically includes missed edge cases, completing what would normally take significant mental energy in minutes, acting like a coding assistant they can review." + }, + "annotations": {}, + "plain_text": "After writing core functionality, they ask Claude to write comprehensive unit tests. Claude automatically includes missed edge cases, completing what would normally take significant mental energy in minutes, acting like a coding assistant they can review. After writing core functionality, they ask Claude to write comprehensive unit tests. Claude automatically includes missed edge cases, completing what would normally take significant mental energy in minutes, acting like a coding assistant they can review." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhnfw59hv9tp9ckstra", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.327769Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Machine learning concept explanation " + }, + "annotations": {}, + "plain_text": "Machine learning concept explanation " + }, + { + "type": "text", + "text": { + "content": "Machine learning concept explanation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Machine learning concept explanation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhpepsst9jkdv2qzwdd", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.327925Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Without a machine learning background, team members depend on Claude to explain model-specific functions and settings. What would require an hour of Google searching and reading documentation now takes 10-20 minutes, reducing research time by 80%. Without a machine learning background, team members depend on Claude to explain model-specific functions and settings. What would require an hour of Google searching and reading documentation now takes 10-20 minutes, reducing research time by 80%." + }, + "annotations": {}, + "plain_text": "Without a machine learning background, team members depend on Claude to explain model-specific functions and settings. What would require an hour of Google searching and reading documentation now takes 10-20 minutes, reducing research time by 80%. Without a machine learning background, team members depend on Claude to explain model-specific functions and settings. What would require an hour of Google searching and reading documentation now takes 10-20 minutes, reducing research time by 80%." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhqf4mvc9vgvv5sp96r", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.328154Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Cross-language code translation " + }, + "annotations": {}, + "plain_text": "Cross-language code translation " + }, + { + "type": "text", + "text": { + "content": "Cross-language code translation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Cross-language code translation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhre1k99ev77pzpz5mw", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.328328Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When testing functionality in different programming languages, they explain what they want to test and Claude writes the logic in the required language (like Rust), eliminating the need to learn new languages just for testing purposes. When testing functionality in different programming languages, they explain what they want to test and Claude writes the logic in the required language (like Rust), eliminating the need to learn new languages just for testing purposes." + }, + "annotations": {}, + "plain_text": "When testing functionality in different programming languages, they explain what they want to test and Claude writes the logic in the required language (like Rust), eliminating the need to learn new languages just for testing purposes. When testing functionality in different programming languages, they explain what they want to test and Claude writes the logic in the required language (like Rust), eliminating the need to learn new languages just for testing purposes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhserjs32tc6pfnyfgf", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.328553Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Command recall and Kubernetes management " + }, + "annotations": {}, + "plain_text": "Command recall and Kubernetes management " + }, + { + "type": "text", + "text": { + "content": "Command recall and Kubemetes management" + }, + "annotations": { + "bold": true + }, + "plain_text": "Command recall and Kubemetes management" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhte5n8x5jc14feprt2", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.328703Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 9 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of remembering complex Kubernetes commands, they ask Claude for the correct syntax, like \"how to get all pods or deployment status,\" and receive the exact commands needed for their infrastructure work. Instead of remembering complex Kubernetes commands, they ask Claude for the correct syntax, like \"how to get all pods or deployment status,\" and receive the exact commands needed for their infrastructure work." + }, + "annotations": {}, + "plain_text": "Instead of remembering complex Kubernetes commands, they ask Claude for the correct syntax, like \"how to get all pods or deployment status,\" and receive the exact commands needed for their infrastructure work. Instead of remembering complex Kubernetes commands, they ask Claude for the correct syntax, like \"how to get all pods or deployment status,\" and receive the exact commands needed for their infrastructure work." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhwf2v8vy3dzmhy1qzt", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.333144Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for inference " + }, + "annotations": {}, + "plain_text": "Claude Code for inference " + }, + { + "type": "text", + "text": { + "content": "Claude Code for inference" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for inference" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhxe9e82yp3fccdg0q1", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.333387Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhyeaf8nam5j9h01wy6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.333600Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Accelerated ML concept learning " + }, + "annotations": {}, + "plain_text": "Team impact Accelerated ML concept learning " + }, + { + "type": "text", + "text": { + "content": "Accelerated ML concept learning" + }, + "annotations": { + "bold": true + }, + "plain_text": "Accelerated ML concept learning" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyhzejz84ensf7wdqqqj", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.333736Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Research time reduced by 80% - what took an hour of Google searching now takes 10-20 minutes. Research time reduced by 80% - what took an hour of Google searching now takes 10-20 minutes." + }, + "annotations": {}, + "plain_text": "Research time reduced by 80% - what took an hour of Google searching now takes 10-20 minutes. Research time reduced by 80% - what took an hour of Google searching now takes 10-20 minutes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj0eav8xq1za9426jg3", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.333953Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Faster codebase navigation " + }, + "annotations": {}, + "plain_text": "Faster codebase navigation " + }, + { + "type": "text", + "text": { + "content": "Faster codebase navigation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Faster codebase navigation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj1f419fx1n9epzqbhr", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.334095Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Can find relevant files and understand system architecture in seconds instead of asking colleagues. Can find relevant files and understand system architecture in seconds instead of asking colleagues." + }, + "annotations": {}, + "plain_text": "Can find relevant files and understand system architecture in seconds instead of asking colleagues. Can find relevant files and understand system architecture in seconds instead of asking colleagues." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj2emzsrhjw3cw2xv5e", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.334312Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Comprehensive test coverage " + }, + "annotations": {}, + "plain_text": "Comprehensive test coverage " + }, + { + "type": "text", + "text": { + "content": "Comprehensive test coverage" + }, + "annotations": { + "bold": true + }, + "plain_text": "Comprehensive test coverage" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj3e23t0eph473vxyyn", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.334445Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude automatically generates unit tests with edge cases, relieving mental burden while maintaining code quality. Claude automatically generates unit tests with edge cases, relieving mental burden while maintaining code quality." + }, + "annotations": {}, + "plain_text": "Claude automatically generates unit tests with edge cases, relieving mental burden while maintaining code quality. Claude automatically generates unit tests with edge cases, relieving mental burden while maintaining code quality." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj4ff0av26p56b1p4j3", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.334744Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Language barrier elimination " + }, + "annotations": {}, + "plain_text": "Language barrier elimination " + }, + { + "type": "text", + "text": { + "content": "Language barrier elimination" + }, + "annotations": { + "bold": true + }, + "plain_text": "Language barrier elimination" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj5fz0ay5ga0cv988c6", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.334879Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Can implement functionality in unfamiliar languages like Rust without needing to learn it. Can implement functionality in unfamiliar languages like Rust without needing to learn it." + }, + "annotations": {}, + "plain_text": "Can implement functionality in unfamiliar languages like Rust without needing to learn it. Can implement functionality in unfamiliar languages like Rust without needing to learn it." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj6f8sa03qswj2s7vnv", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.335107Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Inference team " + }, + "annotations": {}, + "plain_text": "Top tips from the Inference team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Inference team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Inference team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj7eqbrca1kxe617m1e", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.335331Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Test knowledge base functionality first " + }, + "annotations": {}, + "plain_text": "Test knowledge base functionality first " + }, + { + "type": "text", + "text": { + "content": "Test knowledge base functionality first" + }, + "annotations": { + "bold": true + }, + "plain_text": "Test knowledge base functionality first" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj8f7zayghjb75x5646", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.335478Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Try asking various questions to see if Claude can answer faster than Google search. If it's faster and more accurate, it's a valuable time-saving tool for your workflow. Try asking various questions to see if Claude can answer faster than Google search. If it's faster and more accurate, it's a valuable time-saving tool for your workflow." + }, + "annotations": {}, + "plain_text": "Try asking various questions to see if Claude can answer faster than Google search. If it's faster and more accurate, it's a valuable time-saving tool for your workflow. Try asking various questions to see if Claude can answer faster than Google search. If it's faster and more accurate, it's a valuable time-saving tool for your workflow." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyj9fa1t0zftw635spqk", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.335693Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Start with code generation " + }, + "annotations": {}, + "plain_text": "Start with code generation " + }, + { + "type": "text", + "text": { + "content": "Start with code generation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Start with code generation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjae0m9z81vjpk81f0t", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.335835Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Give Claude specific instructions and ask it to write logic, then verify correctness. This helps build trust in the tool's capabilities before using it for more complex tasks. Give Claude specific instructions and ask it to write logic, then verify correctness. This helps build trust in the tool's capabilities before using it for more complex tasks." + }, + "annotations": {}, + "plain_text": "Give Claude specific instructions and ask it to write logic, then verify correctness. This helps build trust in the tool's capabilities before using it for more complex tasks. Give Claude specific instructions and ask it to write logic, then verify correctness. This helps build trust in the tool's capabilities before using it for more complex tasks." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjbfpqsq4e6krkxaxsa", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.336056Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use it for test writing " + }, + "annotations": {}, + "plain_text": "Use it for test writing " + }, + { + "type": "text", + "text": { + "content": "Use it for test writing" + }, + "annotations": { + "bold": true + }, + "plain_text": "Use it for test writing" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjcfxmt6sd2xdrvczre", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.336205Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 10 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Having Claude write unit tests relieves significant pressure from daily development work. Leverage this feature to maintain code quality without spending time thinking through all test cases manually. Having Claude write unit tests relieves significant pressure from daily development work. Leverage this feature to maintain code quality without spending time thinking through all test cases manually." + }, + "annotations": {}, + "plain_text": "Having Claude write unit tests relieves significant pressure from daily development work. Leverage this feature to maintain code quality without spending time thinking through all test cases manually. Having Claude write unit tests relieves significant pressure from daily development work. Leverage this feature to maintain code quality without spending time thinking through all test cases manually." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjeebxv4w9jxqmpxbpn", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.340996Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for data science and visualization " + }, + "annotations": {}, + "plain_text": " Claude Code for data science and visualization " + }, + { + "type": "text", + "text": { + "content": "Claude Code for data science and visualization" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for data science and visualization" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjferjsjb96787ke3zx", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.341193Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Data Science and ML Engineering teams need sophisticated visualization tools to understand model performance, but building these tools often requires expertise in unfamiliar languages and frameworks. Claude Code enables these teams to build production-quality analytics dashboards without becoming full-stack developers. Data Science and ML Engineering teams need sophisticated visualization tools to understand model performance, but building these tools often requires expertise in unfamiliar languages and frameworks. Claude Code enables these teams to build production-quality analytics dashboards without becoming" + }, + "annotations": {}, + "plain_text": "Data Science and ML Engineering teams need sophisticated visualization tools to understand model performance, but building these tools often requires expertise in unfamiliar languages and frameworks. Claude Code enables these teams to build production-quality analytics dashboards without becoming full-stack developers. Data Science and ML Engineering teams need sophisticated visualization tools to understand model performance, but building these tools often requires expertise in unfamiliar languages and frameworks. Claude Code enables these teams to build production-quality analytics dashboards without becoming" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjgfgwsn3rpmkqqnzv0", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.341313Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjhfh1bv43zat1v75w5", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.341543Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Building JavaScript/TypeScript dashboard apps " + }, + "annotations": {}, + "plain_text": "Building JavaScript/TypeScript dashboard apps " + }, + { + "type": "text", + "text": { + "content": "Building JavaScript/Typescript dashboard apps" + }, + "annotations": { + "bold": true + }, + "plain_text": "Building JavaScript/Typescript dashboard apps" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjjf4evvswefne0dnt5", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.341866Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Despite knowing \"very little JavaScript and TypeScript,\" the team uses Claude Code to build entire React applications for visualizing RL model performance and training data. They give Claude control to write full applications from scratch, like a 5,000-line TypeScript app, without needing to understand the code themselves. This is critical because visualization apps are relatively low context and don't require understanding the entire monorepo, allowing rapid prototyping of tools to understand model performance during training and evaluations. full-stack developers. " + }, + "annotations": {}, + "plain_text": "Despite knowing \"very little JavaScript and TypeScript,\" the team uses Claude Code to build entire React applications for visualizing RL model performance and training data. They give Claude control to write full applications from scratch, like a 5,000-line TypeScript app, without needing to understand the code themselves. This is critical because visualization apps are relatively low context and don't require understanding the entire monorepo, allowing rapid prototyping of tools to understand model performance during training and evaluations. full-stack developers. " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + }, + { + "type": "text", + "text": { + "content": " Despite knowing \"very little JavaScript and Typescript,\" the team uses Claude Code to build entire React applications for visualizing RL model performance and training data. They give Claude control to write full applications from scratch, like a 5,000-line Typescript app, without needing to understand the code themselves. This is critical because visualization apps are relatively low context and don't require understanding the entire monorepo, allowing rapid prototyping of tools to understand model performance during training and evaluations." + }, + "annotations": {}, + "plain_text": " Despite knowing \"very little JavaScript and Typescript,\" the team uses Claude Code to build entire React applications for visualizing RL model performance and training data. They give Claude control to write full applications from scratch, like a 5,000-line Typescript app, without needing to understand the code themselves. This is critical because visualization apps are relatively low context and don't require understanding the entire monorepo, allowing rapid prototyping of tools to understand model performance during training and evaluations." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjkfhrvw1rftk4mn8j7", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.342111Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Handling repetitive refactoring tasks " + }, + "annotations": {}, + "plain_text": "Handling repetitive refactoring tasks " + }, + { + "type": "text", + "text": { + "content": "Handling repetitive refactoring tasks" + }, + "annotations": { + "bold": true + }, + "plain_text": "Handling repetitive refactoring tasks" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjmffgtrayxpd734rev", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.342291Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "When faced with merge conflicts or semi-complicated file refactoring that's too complex for editor macros but not large enough for major development effort, they use Claude Code like a \"slot machine\" - commit their state, let Claude work autonomously for 30 minutes, and either accept the solution or restart fresh if it doesn't work. When faced with merge conflicts or semi-complicated file refactoring that's too complex for editor macros but not large enough for major development effort, they use Claude Code like a \"slot machine\" - commit their state, let Claude work autonomously for 30 minutes, and either accept the solution or restart fresh if it doesn't work." + }, + "annotations": {}, + "plain_text": "When faced with merge conflicts or semi-complicated file refactoring that's too complex for editor macros but not large enough for major development effort, they use Claude Code like a \"slot machine\" - commit their state, let Claude work autonomously for 30 minutes, and either accept the solution or restart fresh if it doesn't work. When faced with merge conflicts or semi-complicated file refactoring that's too complex for editor macros but not large enough for major development effort, they use Claude Code like a \"slot machine\" - commit their state, let Claude work autonomously for 30 minutes, and either accept the solution or restart fresh if it doesn't work." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjnf589tks6q5xyngqp", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.342518Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Creating persistent analytics tools instead of throwaway notebooks " + }, + "annotations": {}, + "plain_text": "Creating persistent analytics tools instead of throwaway notebooks " + }, + { + "type": "text", + "text": { + "content": "Creating persistent analytics tools instead of throwaway notebooks" + }, + "annotations": { + "bold": true + }, + "plain_text": "Creating persistent analytics tools instead of throwaway notebooks" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjpepnafrbcwx57ts9y", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.342716Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of building one-off Jupyter notebooks that get discarded, the team now has Claude build permanent React dashboards that can be reused across future model evaluations. This is important because understanding Claude's performance is \"one of the most important things for the team\" - they need to understand how models perform during training and evaluations, which \"is actually non-trivial and simple tools can't get too much signal from looking at a single number go up.\" Instead of building one-off Jupyter notebooks that get discarded, the team now has Claude build permanent React dashboards that can be reused across future model evaluations. This is important because understanding Claude's performance is \"one of the most important things for the team\" - they need to understand how models perform during training and evaluations, which \"is actually non-trivial and simple tools can't get too much signal from looking at a single number go up.\"" + }, + "annotations": {}, + "plain_text": "Instead of building one-off Jupyter notebooks that get discarded, the team now has Claude build permanent React dashboards that can be reused across future model evaluations. This is important because understanding Claude's performance is \"one of the most important things for the team\" - they need to understand how models perform during training and evaluations, which \"is actually non-trivial and simple tools can't get too much signal from looking at a single number go up.\" Instead of building one-off Jupyter notebooks that get discarded, the team now has Claude build permanent React dashboards that can be reused across future model evaluations. This is important because understanding Claude's performance is \"one of the most important things for the team\" - they need to understand how models perform during training and evaluations, which \"is actually non-trivial and simple tools can't get too much signal from looking at a single number go up.\"" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjqfba85sdhb0qvr7t8", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.342939Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Zero-dependency task delegation " + }, + "annotations": {}, + "plain_text": "Zero-dependency task delegation " + }, + { + "type": "text", + "text": { + "content": "Zero-dependency task delegation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Zero-dependency task delegation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjre5ds7hrp35vtcmxq", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.343122Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 11 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "For tasks in completely unfamiliar codebases or languages, they delegate entire implementation to Claude Code, leveraging its ability to gather context from the monorepo and execute tasks without their involvement in the actual coding process. This allows productivity in areas outside their expertise instead of spending time learning new technologies. For tasks in completely unfamiliar codebases or languages, they delegate entire implementation to Claude Code, leveraging its ability to gather context from the monorepo and execute tasks without their involvement in the actual coding process. This allows productivity in areas outside their expertise instead of spending time learning new technologies." + }, + "annotations": {}, + "plain_text": "For tasks in completely unfamiliar codebases or languages, they delegate entire implementation to Claude Code, leveraging its ability to gather context from the monorepo and execute tasks without their involvement in the actual coding process. This allows productivity in areas outside their expertise instead of spending time learning new technologies. For tasks in completely unfamiliar codebases or languages, they delegate entire implementation to Claude Code, leveraging its ability to gather context from the monorepo and execute tasks without their involvement in the actual coding process. This allows productivity in areas outside their expertise instead of spending time learning new technologies." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjtf1qtbdjzwtq159xy", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.347968Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for data science and visualization " + }, + "annotations": {}, + "plain_text": "Claude Code for data science and visualization " + }, + { + "type": "text", + "text": { + "content": "Claude Code for data science and visualization" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for data science and visualization" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjxefm82jzg8p93ek0j", + "type": "table", + "created_time": "2025-06-16T14:04:08.348865Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "table": { + "has_column_header": true, + "has_row_header": false + }, + "children": [ + { + "object": "block", + "id": "bk_01jxwgvyjvfz38e4t210phy39t", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.348455Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "table_row": { + "cells": [ + [ + { + "type": "text", + "text": { + "content": "Team impact Team impact" + }, + "annotations": {}, + "plain_text": "Team impact Team impact" + }, + { + "type": "text", + "text": { + "content": "Team impact Team impact" + }, + "annotations": {}, + "plain_text": "Team impact Team impact" + } + ], + [], + [ + { + "type": "text", + "text": { + "content": "Achieved 2-4x time savings Achieved 2-4x time savings" + }, + "annotations": {}, + "plain_text": "Achieved 2-4x time savings Achieved 2-4x time savings" + }, + { + "type": "text", + "text": { + "content": "Achieved 2-4x time savings Achieved 2-4x time savings" + }, + "annotations": {}, + "plain_text": "Achieved 2-4x time savings Achieved 2-4x time savings" + } + ], + [] + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjweb4anbx8mmwahr3p", + "type": "table_row", + "created_time": "2025-06-16T14:04:08.348669Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "table_row": { + "cells": [[], [], [], []] + } + } + ] + }, + { + "object": "block", + "id": "bk_01jxwgvyjyfe4s2qtqp6b98a0s", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.349124Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Achieved 2-4x time savings" + }, + "annotations": { + "bold": true + }, + "plain_text": "Achieved 2-4x time savings" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyjzfb89frrm9y5y4ydb", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.349244Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Routine refactoring tasks that were tedious but manageable manually are now completed much faster. Routine refactoring tasks that were tedious but manageable manually are now completed much faster." + }, + "annotations": {}, + "plain_text": "Routine refactoring tasks that were tedious but manageable manually are now completed much faster. Routine refactoring tasks that were tedious but manageable manually are now completed much faster." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk0fqmb7mftnzwg4ktw", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.349474Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Built complex applications in unfamiliar languages " + }, + "annotations": {}, + "plain_text": "Built complex applications in unfamiliar languages " + }, + { + "type": "text", + "text": { + "content": "Built complex applications in unfamiliar languages" + }, + "annotations": { + "bold": true + }, + "plain_text": "Built complex applications in unfamiliar languages" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk1e7hafg7cdkvj0j3f", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.349603Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Created 5,000-line TypeScript applications despite having minimal JavaScript/TypeScript experience. Created 5,000-line Typescript applications despite having minimal JavaScript/Typescript experience." + }, + "annotations": {}, + "plain_text": "Created 5,000-line TypeScript applications despite having minimal JavaScript/TypeScript experience. Created 5,000-line Typescript applications despite having minimal JavaScript/Typescript experience." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk2f3psn99qtnyms53t", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.349847Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Shifted from throwaway to persistent tools " + }, + "annotations": {}, + "plain_text": "Shifted from throwaway to persistent tools " + }, + { + "type": "text", + "text": { + "content": "Shifted from throwaway to persistent tools" + }, + "annotations": { + "bold": true + }, + "plain_text": "Shifted from throwaway to persistent tools" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk3f36ak3qtxbjebp63", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.349994Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of disposable Jupyter notebooks, now building reusable React dashboards for model analysis. Instead of disposable Jupyter notebooks, now building reusable React dashboards for model analysis." + }, + "annotations": {}, + "plain_text": "Instead of disposable Jupyter notebooks, now building reusable React dashboards for model analysis. Instead of disposable Jupyter notebooks, now building reusable React dashboards for model analysis." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk4f1mty7mq3mwzazvb", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.350230Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Direct model improvement insights " + }, + "annotations": {}, + "plain_text": "Direct model improvement insights " + }, + { + "type": "text", + "text": { + "content": "Direct model improvement insights" + }, + "annotations": { + "bold": true + }, + "plain_text": "Direct model improvement insights" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk5e3drp1e5y3kd782a", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.350369Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Firsthand Claude Code experience informs development of better memory systems and UX improvements for future model iterations. Firsthand Claude Code experience informs development of better memory systems and UX improvements for future model iterations." + }, + "annotations": {}, + "plain_text": "Firsthand Claude Code experience informs development of better memory systems and UX improvements for future model iterations. Firsthand Claude Code experience informs development of better memory systems and UX improvements for future model iterations." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk6ec39jqaxjdkm1kv5", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.350586Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enabled visualization-driven decision making " + }, + "annotations": {}, + "plain_text": "Enabled visualization-driven decision making " + }, + { + "type": "text", + "text": { + "content": "Enabled visualization-driven decision making" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enabled visualization-driven decision making" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk7ep9rsnert6cg9891", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.350717Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Better understanding of Claude's performance during training and evaluations through advanced data visualization tools. Better understanding of Claude's performance during training and evaluations through advanced data visualization tools." + }, + "annotations": {}, + "plain_text": "Better understanding of Claude's performance during training and evaluations through advanced data visualization tools. Better understanding of Claude's performance during training and evaluations through advanced data visualization tools." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk8ed9ary6bvrj5fkrb", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.350934Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Data Science and ML Engineering teams " + }, + "annotations": {}, + "plain_text": "Top tips from the Data Science and ML Engineering teams " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Data Science and ML Engineering teams" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Data Science and ML Engineering teams" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyk9fj9bfhgv2crmn5a0", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.351158Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Treat it like a slot machine " + }, + "annotations": {}, + "plain_text": "Treat it like a slot machine " + }, + { + "type": "text", + "text": { + "content": "Treat it like a slot machine" + }, + "annotations": { + "bold": true + }, + "plain_text": "Treat it like a slot machine" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykae21bqbdawzwak99x", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.351324Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Save your state before letting Claude work, let it run for 30 minutes, then either accept the result or start fresh rather than trying to wrestle with corrections. Starting over often has a higher success rate than trying to fix Claude's mistakes. Save your state before letting Claude work, let it run for 30 minutes, then either accept the result or start fresh rather than trying to wrestle with corrections. Starting over often has a higher success rate than trying to fix Claude's mistakes." + }, + "annotations": {}, + "plain_text": "Save your state before letting Claude work, let it run for 30 minutes, then either accept the result or start fresh rather than trying to wrestle with corrections. Starting over often has a higher success rate than trying to fix Claude's mistakes. Save your state before letting Claude work, let it run for 30 minutes, then either accept the result or start fresh rather than trying to wrestle with corrections. Starting over often has a higher success rate than trying to fix Claude's mistakes." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykbebgb8crh0bbqq5dx", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.351543Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Interrupt for simplicity when needed " + }, + "annotations": {}, + "plain_text": "Interrupt for simplicity when needed " + }, + { + "type": "text", + "text": { + "content": "Interrupt for simplicity when needed" + }, + "annotations": { + "bold": true + }, + "plain_text": "Interrupt for simplicity when needed" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykcf1qs3jkwfce8rd25", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.351698Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 12 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "While supervising, don't hesitate to stop Claude and ask \"why are you doing this? Try something simpler.\" The model tends toward more complex solutions by default but responds well to requests for simpler approaches. While supervising, don't hesitate to stop Claude and ask \"why are you doing this? Try something simpler.\" The model tends toward more complex solutions by default but responds well to requests for simpler approaches." + }, + "annotations": {}, + "plain_text": "While supervising, don't hesitate to stop Claude and ask \"why are you doing this? Try something simpler.\" The model tends toward more complex solutions by default but responds well to requests for simpler approaches. While supervising, don't hesitate to stop Claude and ask \"why are you doing this? Try something simpler.\" The model tends toward more complex solutions by default but responds well to requests for simpler approaches." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykeed6sxt51tr6hvqa6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.356781Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for API " + }, + "annotations": {}, + "plain_text": " Claude Code for API " + }, + { + "type": "text", + "text": { + "content": "Claude Code for API" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for API" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykfex6ax0hhm5yj31aq", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.357012Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The API Knowledge team works on features like PDF support, citations, and web search that bring additional knowledge into Claude's context window. Working across large, complex codebases means constantly encountering unfamiliar code sections, spending significant time understanding which files to examine for any given task, and building context before making changes. Claude Code improves this experience by serving as a guide that can help them understand system architecture, identify relevant files, and explain complex interactions. The API Knowledge team works on features like PDF support, citations, and web search that bring additional knowledge into Claude's context window. Working across large, complex codebases means constantly encountering unfamiliar code sections, spending significant time understanding which files to examine for any given task, and building context before making changes. Claude Code improves this experience by serving as a guide that can help them understand system architecture, identify relevant files, and explain complex interactions." + }, + "annotations": {}, + "plain_text": "The API Knowledge team works on features like PDF support, citations, and web search that bring additional knowledge into Claude's context window. Working across large, complex codebases means constantly encountering unfamiliar code sections, spending significant time understanding which files to examine for any given task, and building context before making changes. Claude Code improves this experience by serving as a guide that can help them understand system architecture, identify relevant files, and explain complex interactions. The API Knowledge team works on features like PDF support, citations, and web search that bring additional knowledge into Claude's context window. Working across large, complex codebases means constantly encountering unfamiliar code sections, spending significant time understanding which files to examine for any given task, and building context before making changes. Claude Code improves this experience by serving as a guide that can help them understand system architecture, identify relevant files, and explain complex interactions." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykgfxwt7s9czcwjrv1q", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.357252Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases " + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykhf47awnkt4d0mfsv6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.357481Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "First-step workflow planning " + }, + "annotations": {}, + "plain_text": "First-step workflow planning " + }, + { + "type": "text", + "text": { + "content": "First-step workflow planning" + }, + "annotations": { + "bold": true + }, + "plain_text": "First-step workflow planning" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykjf628xn9yvwc89qp1", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.357647Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team uses Claude Code as their \"first stop\" for any task, asking it to identify which files to examine for bug fixes, feature development, or analysis. This replaces the traditional time-consuming process of manually navigating the codebase and gathering context before starting work. The team uses Claude Code as their \"first stop\" for any task, asking it to identify which files to examine for bug fixes, feature development, or analysis. This replaces the traditional time-consuming process of manually navigating the codebase and gathering context before starting work." + }, + "annotations": {}, + "plain_text": "The team uses Claude Code as their \"first stop\" for any task, asking it to identify which files to examine for bug fixes, feature development, or analysis. This replaces the traditional time-consuming process of manually navigating the codebase and gathering context before starting work. The team uses Claude Code as their \"first stop\" for any task, asking it to identify which files to examine for bug fixes, feature development, or analysis. This replaces the traditional time-consuming process of manually navigating the codebase and gathering context before starting work." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykkfk7bnpp40393sym6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.357867Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Independent debugging across codebases " + }, + "annotations": {}, + "plain_text": "Independent debugging across codebases " + }, + { + "type": "text", + "text": { + "content": "Independent debugging across codebases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Independent debugging across codebases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykmfm3sq45mrk2ad0ha", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.358044Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team now has the confidence to tackle bugs in unfamiliar parts of the codebase instead of asking others for help. They can ask Claude \"Do you think you can fix this bug? This is the behavior I'm seeing\" and often get immediate progress, which wasn't feasible before given the time investment required. The team now has the confidence to tackle bugs in unfamiliar parts of the code base instead of asking others for help. They can ask Claude \"Do you think you can fix this bug? This is the behavior I'm seeing\" and often get immediate progress, which wasn't feasible before given the time investment required." + }, + "annotations": {}, + "plain_text": "The team now has the confidence to tackle bugs in unfamiliar parts of the codebase instead of asking others for help. They can ask Claude \"Do you think you can fix this bug? This is the behavior I'm seeing\" and often get immediate progress, which wasn't feasible before given the time investment required. The team now has the confidence to tackle bugs in unfamiliar parts of the code base instead of asking others for help. They can ask Claude \"Do you think you can fix this bug? This is the behavior I'm seeing\" and often get immediate progress, which wasn't feasible before given the time investment required." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyknfx3bvykfcvmtpeph", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.358267Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Model iteration testing through dogfooding " + }, + "annotations": {}, + "plain_text": "Model iteration testing through dogfooding " + }, + { + "type": "text", + "text": { + "content": "Model iteration testing through dogfooding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Model iteration testing through dogfooding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykpefrs3t5t05qmtdbb", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.358427Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code automatically uses the latest research model snapshots, making it their primary way of experiencing model changes. This gives them direct feedback on model behavior changes during development cycles, which they hadn't experienced during previous launches. Claude Code automatically uses the latest research model snapshots, making it their primary way of experiencing model changes. This gives them direct feedback on model behavior changes during development cycles, which they hadn't experienced during previous launches." + }, + "annotations": {}, + "plain_text": "Claude Code automatically uses the latest research model snapshots, making it their primary way of experiencing model changes. This gives them direct feedback on model behavior changes during development cycles, which they hadn't experienced during previous launches. Claude Code automatically uses the latest research model snapshots, making it their primary way of experiencing model changes. This gives them direct feedback on model behavior changes during development cycles, which they hadn't experienced during previous launches." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykqfh79k36v5pw5468t", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.358644Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Eliminating context-switching overhead " + }, + "annotations": {}, + "plain_text": "Eliminating context-switching overhead " + }, + { + "type": "text", + "text": { + "content": "Eliminating context-switching overhead" + }, + "annotations": { + "bold": true + }, + "plain_text": "Eliminating context-switching overhead" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykrfxx9w944svhswbt6", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.358792Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 13 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of copying code snippets and dragging files into Claude.ai while explaining problems extensively, they can ask questions directly in Claude Code without additional context gathering, significantly reducing mental overhead. Instead of copying code snippets and dragging files into Claude.ai while explaining problems extensively, they can ask questions directly in Claude Code without additional context gathering, significantly reducing mental overhead." + }, + "annotations": {}, + "plain_text": "Instead of copying code snippets and dragging files into Claude.ai while explaining problems extensively, they can ask questions directly in Claude Code without additional context gathering, significantly reducing mental overhead. Instead of copying code snippets and dragging files into Claude.ai while explaining problems extensively, they can ask questions directly in Claude Code without additional context gathering, significantly reducing mental overhead." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyktese8kg61zdmj95dy", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.362891Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for API " + }, + "annotations": {}, + "plain_text": "Claude Code for API " + }, + { + "type": "text", + "text": { + "content": "Claude Code for API" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for API" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykveast6a9t5emr29h3", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.363138Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykwe6zad151p3w919pv", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.363361Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Increased confidence in tackling unfamiliar areas " + }, + "annotations": {}, + "plain_text": "Team impact Increased confidence in tackling unfamiliar areas " + }, + { + "type": "text", + "text": { + "content": "Increased confidence in tackling unfamiliar areas" + }, + "annotations": { + "bold": true + }, + "plain_text": "Increased confidence in tackling unfamiliar areas" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykxex980vcsgdfqkmpa", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.363492Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team members can independently debug bugs and investigate incidents in unfamiliar codebases. Team members can independently debug bugs and investigate incidents in unfamiliar codebases." + }, + "annotations": {}, + "plain_text": "Team members can independently debug bugs and investigate incidents in unfamiliar codebases. Team members can independently debug bugs and investigate incidents in unfamiliar codebases." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykyemqbrm9qgbnv6zbq", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.363714Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Significant time savings in context gathering " + }, + "annotations": {}, + "plain_text": "Significant time savings in context gathering " + }, + { + "type": "text", + "text": { + "content": "Significant time savings in context gathering" + }, + "annotations": { + "bold": true + }, + "plain_text": "Significant time savings in context gathering" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvykzfsb9qyb8mxz4azw7", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.363852Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Eliminated the overhead of copying code snippets and dragging files into Claude.ai, reducing mental context-switching burden. Eliminated the overhead of copying code snippets and dragging files into Claude.ai, reducing mental context-switching burden." + }, + "annotations": {}, + "plain_text": "Eliminated the overhead of copying code snippets and dragging files into Claude.ai, reducing mental context-switching burden. Eliminated the overhead of copying code snippets and dragging files into Claude.ai, reducing mental context-switching burden." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym0frcsb3z9mmtjdbv7", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.364163Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Faster rotation onboarding " + }, + "annotations": {}, + "plain_text": "Faster rotation onboarding " + }, + { + "type": "text", + "text": { + "content": "Faster rotation onboarding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Faster rotation onboarding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym1fbpay24a8fy4hw24", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.364580Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Engineers rotating to new teams can quickly navigate unfamiliar codebases and contribute meaningfully without extensive colleague consultation. Engineers rotating to new teams can quickly navigate unfamiliar code bases and contribute meaningfully without extensive colleague consultation." + }, + "annotations": {}, + "plain_text": "Engineers rotating to new teams can quickly navigate unfamiliar codebases and contribute meaningfully without extensive colleague consultation. Engineers rotating to new teams can quickly navigate unfamiliar code bases and contribute meaningfully without extensive colleague consultation." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym2fq6bvdywwdy0f5n2", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.365167Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Enhanced developer happiness " + }, + "annotations": {}, + "plain_text": "Enhanced developer happiness " + }, + { + "type": "text", + "text": { + "content": "Enhanced developer happiness" + }, + "annotations": { + "bold": true + }, + "plain_text": "Enhanced developer happiness" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym3f88ryfg5m3vk9w4c", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.365307Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team reports feeling happier and more productive with reduced friction in daily workflows. Team reports feeling happier and more productive with reduced friction in daily workflows." + }, + "annotations": {}, + "plain_text": "Team reports feeling happier and more productive with reduced friction in daily workflows. Team reports feeling happier and more productive with reduced friction in daily workflows." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym4fwf8kzpqpqt9dy2t", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.365532Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the API Knowledge team " + }, + "annotations": {}, + "plain_text": "Top tips from the API Knowledge team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the API Knowledge team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the API Knowledge team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym5fvb8t22tr9qg6jba", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.365757Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Treat it as an iterative partner, not a one-shot solution " + }, + "annotations": {}, + "plain_text": "Treat it as an iterative partner, not a one-shot solution " + }, + { + "type": "text", + "text": { + "content": "Treat it as an iterative partner, not a one-shot solution" + }, + "annotations": { + "bold": true + }, + "plain_text": "Treat it as an iterative partner, not a one-shot solution" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym6fapry7x4cetnjmn2", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.365904Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Rather than expecting Claude to solve problems immediately, approach it as a collaborator you iterate with. This works better than trying to get perfect solutions on the first try. Rather than expecting Claude to solve problems immediately, approach it as a collaborator you iterate with. This works better than trying to get perfect solutions on the first try." + }, + "annotations": {}, + "plain_text": "Rather than expecting Claude to solve problems immediately, approach it as a collaborator you iterate with. This works better than trying to get perfect solutions on the first try. Rather than expecting Claude to solve problems immediately, approach it as a collaborator you iterate with. This works better than trying to get perfect solutions on the first try." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym7f4tb7hxw4qqy91s5", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.366133Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use it for building confidence in unfamiliar areas " + }, + "annotations": {}, + "plain_text": "Use it for building confidence in unfamiliar areas " + }, + { + "type": "text", + "text": { + "content": "Use it for building confidence in unfamiliar areas" + }, + "annotations": { + "bold": true + }, + "plain_text": "Use it for building confidence in unfamiliar areas" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym8fde8nrpf94qtk56b", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.366280Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Don't hesitate to tackle bugs or investigate incidents outside your expertise - Claude Code makes it feasible to work independently in areas that would normally require extensive context building. Don't hesitate to tackle bugs or investigate incidents outside your expertise - Claude Code makes it feasible to work independently in areas that would normally require extensive context building." + }, + "annotations": {}, + "plain_text": "Don't hesitate to tackle bugs or investigate incidents outside your expertise - Claude Code makes it feasible to work independently in areas that would normally require extensive context building. Don't hesitate to tackle bugs or investigate incidents outside your expertise - Claude Code makes it feasible to work independently in areas that would normally require extensive context building." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvym9f5ar5z5fc1tfb0jm", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.366492Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Start with minimal information " + }, + "annotations": {}, + "plain_text": "Start with minimal information " + }, + { + "type": "text", + "text": { + "content": "Start with minimal information" + }, + "annotations": { + "bold": true + }, + "plain_text": "Start with minimal information" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymaf9mv64c10kem1j3v", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.366629Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 14 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Begin with just the bare minimum of what you need and let Claude guide you through the process, rather than front-loading extensive explanations. Begin with just the bare minimum of what you need and let Claude guide you through the process, rather than front-loading extensive explanations." + }, + "annotations": {}, + "plain_text": "Begin with just the bare minimum of what you need and let Claude guide you through the process, rather than front-loading extensive explanations. Begin with just the bare minimum of what you need and let Claude guide you through the process, rather than front-loading extensive explanations." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymcecwt1j1yy5x3f79a", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.371361Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for growth marketing " + }, + "annotations": {}, + "plain_text": " Claude Code for growth marketing " + }, + { + "type": "text", + "text": { + "content": "Claude Code for growth marketing" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for growth marketing" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymdedfb67pm5x5sccq6", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.371552Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Growth Marketing team focuses on building out performance marketing channels across paid search, paid social, mobile app stores, email marketing, and SEO. As a nontechnical team of one, they use Claude Code to automate repetitive marketing tasks and create agentic workflows that would traditionally require significant engineering resources. The Growth Marketing team focuses on building out performance marketing channels across paid search, paid social, mobile opp stores, email marketing, and SEO. As a nontechnical team of one, they use Claude Code to automate repetitive marketing tasks and create agentic workflows that would traditionally require significant engineering" + }, + "annotations": {}, + "plain_text": "The Growth Marketing team focuses on building out performance marketing channels across paid search, paid social, mobile app stores, email marketing, and SEO. As a nontechnical team of one, they use Claude Code to automate repetitive marketing tasks and create agentic workflows that would traditionally require significant engineering resources. The Growth Marketing team focuses on building out performance marketing channels across paid search, paid social, mobile opp stores, email marketing, and SEO. As a nontechnical team of one, they use Claude Code to automate repetitive marketing tasks and create agentic workflows that would traditionally require significant engineering" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymeejwbawp8w1h838x1", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.371669Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymfe0nt1dds2za5ntfh", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.371892Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Automated Google Ads creative generation " + }, + "annotations": {}, + "plain_text": "Automated Google Ads creative generation " + }, + { + "type": "text", + "text": { + "content": "Automated Google Ads creative generation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Automated Google Ads creative generation" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymge4grf0a71nwgar44", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.372244Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team built an agentic workflow that processes CSV files containing hundreds of existing ads with performance metrics, identifies underperforming ads for iteration, and generates new variations that meet strict character limits (30 characters for headlines, 90 for descriptions). Using two specialized sub-agents (one for headlines, one for descriptions), the system can generate hundreds of new ads in minutes instead of requiring manual creation across multiple campaigns. This has enabled them to test and iterate at scale, something that would have taken a significant amount of time to achieve previously. resources. " + }, + "annotations": {}, + "plain_text": "The team built an agentic workflow that processes CSV files containing hundreds of existing ads with performance metrics, identifies underperforming ads for iteration, and generates new variations that meet strict character limits (30 characters for headlines, 90 for descriptions). Using two specialized sub-agents (one for headlines, one for descriptions), the system can generate hundreds of new ads in minutes instead of requiring manual creation across multiple campaigns. This has enabled them to test and iterate at scale, something that would have taken a significant amount of time to achieve previously. resources. " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + }, + { + "type": "text", + "text": { + "content": " The team built an agentic workflow that processes CSV files containing hundreds of existing ads with performance metrics, identifies underperforming ads for iteration, and generates new variations that meet strict character limits (30 characters for headlines, 90 for descriptions). Using two specialized sub-agents (one for headlines, one for descriptions), the system can generate hundreds of new ads in minutes instead of requiring manual creation across multiple campaigns. This has enabled them to test and iterate at scale, something that would have taken a significant amount of time to achieve previously." + }, + "annotations": {}, + "plain_text": " The team built an agentic workflow that processes CSV files containing hundreds of existing ads with performance metrics, identifies underperforming ads for iteration, and generates new variations that meet strict character limits (30 characters for headlines, 90 for descriptions). Using two specialized sub-agents (one for headlines, one for descriptions), the system can generate hundreds of new ads in minutes instead of requiring manual creation across multiple campaigns. This has enabled them to test and iterate at scale, something that would have taken a significant amount of time to achieve previously." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymhfapv0em0ens18fyw", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.372491Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Figma plugin for mass creative production " + }, + "annotations": {}, + "plain_text": "Figma plugin for mass creative production " + }, + { + "type": "text", + "text": { + "content": "Figma plugin for mass creative production" + }, + "annotations": { + "bold": true + }, + "plain_text": "Figma plugin for mass creative production" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymjf47sn1fezm24x7va", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.372682Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of manually duplicating and editing static images for paid social ads, they developed a Figma plugin that identifies frames and programmatically generates up to 100 ad variations by swapping headlines and descriptions, reducing what would take hours of copypasting to half a second per batch. This enables 10x creative output, allowing the team to test vastly more creative variations across key social channels. Instead of manually duplicating and editing static images for paid social ads, they developed a Figma plugin that identifies frames and programmatically generates up to 100 ad variations by swapping headlines and descriptions, reducing what would take hours of copypasting to half a second per batch. This enables l0x creative output, allowing the team to test vastly more creative variations across key social channels." + }, + "annotations": {}, + "plain_text": "Instead of manually duplicating and editing static images for paid social ads, they developed a Figma plugin that identifies frames and programmatically generates up to 100 ad variations by swapping headlines and descriptions, reducing what would take hours of copypasting to half a second per batch. This enables 10x creative output, allowing the team to test vastly more creative variations across key social channels. Instead of manually duplicating and editing static images for paid social ads, they developed a Figma plugin that identifies frames and programmatically generates up to 100 ad variations by swapping headlines and descriptions, reducing what would take hours of copypasting to half a second per batch. This enables l0x creative output, allowing the team to test vastly more creative variations across key social channels." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymkft3s6kvgvyvvdd0r", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.372904Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Meta Ads MCP server for campaign analytics " + }, + "annotations": {}, + "plain_text": "Meta Ads MCP server for campaign analytics " + }, + { + "type": "text", + "text": { + "content": "Meta Ads MCP server for campaign analytics" + }, + "annotations": { + "bold": true + }, + "plain_text": "Meta Ads MCP server for campaign analytics" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymmf2b8zsj1nz225v02", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.373078Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They created an MCP server integrated with Meta Ads API to query campaign performance, spending data, and ad effectiveness directly within the Claude Desktop app, eliminating the need to switch between platforms for performance analysis, saving critical time where every efficiency gain translates to better ROI. They created an MCP server integrated with Meta Ads API to query campaign performance, spending data, and ad effectiveness directly within the Claude Desktop app, eliminating the need to switch between platforms for performance analysis, saving critical time where every efficiency gain translates to better ROI." + }, + "annotations": {}, + "plain_text": "They created an MCP server integrated with Meta Ads API to query campaign performance, spending data, and ad effectiveness directly within the Claude Desktop app, eliminating the need to switch between platforms for performance analysis, saving critical time where every efficiency gain translates to better ROI. They created an MCP server integrated with Meta Ads API to query campaign performance, spending data, and ad effectiveness directly within the Claude Desktop app, eliminating the need to switch between platforms for performance analysis, saving critical time where every efficiency gain translates to better ROI." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymne74t765p6acvxmwd", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.373304Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Advanced prompt engineering with memory systems " + }, + "annotations": {}, + "plain_text": "Advanced prompt engineering with memory systems " + }, + { + "type": "text", + "text": { + "content": "Advanced prompt engineering with memory systems" + }, + "annotations": { + "bold": true + }, + "plain_text": "Advanced prompt engineering with memory systems" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvympeyktz2v9swvjt84h", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.373471Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 15 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They implemented a rudimentary memory system that logs hypotheses and experiments across ad iterations, allowing the system to pull previous test results into context when generating new variations, creating a selfimproving testing framework. This enables systematic experimentation that would be impossible to track manually. They implemented a rudimentary memory system that logs hypotheses and experiments across ad iterations, allowing the system to pull previous test results into context when generating new variations, creating a selfimproving testing framework. This enables systematic experimentation that would be impossible to track manually." + }, + "annotations": {}, + "plain_text": "They implemented a rudimentary memory system that logs hypotheses and experiments across ad iterations, allowing the system to pull previous test results into context when generating new variations, creating a selfimproving testing framework. This enables systematic experimentation that would be impossible to track manually. They implemented a rudimentary memory system that logs hypotheses and experiments across ad iterations, allowing the system to pull previous test results into context when generating new variations, creating a selfimproving testing framework. This enables systematic experimentation that would be impossible to track manually." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymrepwa8grnserr6z4m", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.377791Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for growth marketing " + }, + "annotations": {}, + "plain_text": "Claude Code for growth marketing " + }, + { + "type": "text", + "text": { + "content": "Claude Code for growth marketing" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for growth marketing" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymse169pwtjjymem20h", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.378038Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymtfrx90n21ae5s1xb1", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.378261Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Dramatic time savings on repetitive tasks " + }, + "annotations": {}, + "plain_text": "Team impact Dramatic time savings on repetitive tasks " + }, + { + "type": "text", + "text": { + "content": "Dramatic time savings on repetitive tasks" + }, + "annotations": { + "bold": true + }, + "plain_text": "Dramatic time savings on repetitive tasks" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymvfppbtpsfpme83fp4", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.378396Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Ad copy creation reduced from 2 hours to 15 minutes, freeing up time for strategic work. Ad copy creation reduced from 2 hours to 15 minutes, freeing up time for strategic work." + }, + "annotations": {}, + "plain_text": "Ad copy creation reduced from 2 hours to 15 minutes, freeing up time for strategic work. Ad copy creation reduced from 2 hours to 15 minutes, freeing up time for strategic work." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymwfy3srndw99vk95ep", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.378618Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "10x increase in creative output " + }, + "annotations": {}, + "plain_text": "10x increase in creative output " + }, + { + "type": "text", + "text": { + "content": "10x increase in creative output" + }, + "annotations": { + "bold": true + }, + "plain_text": "10x increase in creative output" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymxe17ae0w9nw4dj792", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.378749Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team can now test vastly more ad variations across channels with automated generation and Figma integration. The team can now test vastly more ad variations across channels with automated generation and Figma integration." + }, + "annotations": {}, + "plain_text": "The team can now test vastly more ad variations across channels with automated generation and Figma integration. The team can now test vastly more ad variations across channels with automated generation and Figma integration." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymyf13bqw1fb5ax6qaz", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.378969Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Operating like a larger team " + }, + "annotations": {}, + "plain_text": "Operating like a larger team " + }, + { + "type": "text", + "text": { + "content": "Operating like a larger team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Operating like a larger team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvymzer6bfj6n74r8cye6", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.379105Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team can handle tasks that traditionally required dedicated engineering resources. The team can handle tasks that traditionally required dedicated engineering resources." + }, + "annotations": {}, + "plain_text": "The team can handle tasks that traditionally required dedicated engineering resources. The team can handle tasks that traditionally required dedicated engineering resources." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn0ehs85gq5zzxaxvmz", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.379327Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Strategic focus shift " + }, + "annotations": {}, + "plain_text": "Strategic focus shift " + }, + { + "type": "text", + "text": { + "content": "Strategic focus shift" + }, + "annotations": { + "bold": true + }, + "plain_text": "Strategic focus shift" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn1ep1a5br8p6880t58", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.379458Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The team can spend more time on overall strategy and building agentic automation rather than manual execution. The team can spend more time on overall strategy and building agentic automation rather than manual execution." + }, + "annotations": {}, + "plain_text": "The team can spend more time on overall strategy and building agentic automation rather than manual execution. The team can spend more time on overall strategy and building agentic automation rather than manual execution." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn2eyqvta6hjxgeqe3y", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.379674Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Growth Marketing team " + }, + "annotations": {}, + "plain_text": "Top tips from the Growth Marketing team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Growth Marketing team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Growth Marketing team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn3ephbkgtf81zdz6ss", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.379887Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Identify API-enabled repetitive tasks " + }, + "annotations": {}, + "plain_text": "Identify API-enabled repetitive tasks " + }, + { + "type": "text", + "text": { + "content": "Identify API-enabled repetitive tasks" + }, + "annotations": { + "bold": true + }, + "plain_text": "Identify API-enabled repetitive tasks" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn4fr1vvtec63g1453r", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.380045Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Look for workflows involving repetitive actions with tools that have APIs (like ad platforms, design tools, analytics platforms). These are prime candidates for automation and where Claude Code provides the most value. Look for workflows involving repetitive actions with tools that have APis (like ad platforms, design tools, analytics platforms). These are prime candidates for automation and where Claude Code provides the most value." + }, + "annotations": {}, + "plain_text": "Look for workflows involving repetitive actions with tools that have APIs (like ad platforms, design tools, analytics platforms). These are prime candidates for automation and where Claude Code provides the most value. Look for workflows involving repetitive actions with tools that have APis (like ad platforms, design tools, analytics platforms). These are prime candidates for automation and where Claude Code provides the most value." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn5egvrqrz63p7txyzy", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.380287Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Break complex workflows into specialized sub-agents " + }, + "annotations": {}, + "plain_text": "Break complex workflows into specialized sub-agents " + }, + { + "type": "text", + "text": { + "content": "Break complex workflows into specialized sub-agents" + }, + "annotations": { + "bold": true + }, + "plain_text": "Break complex workflows into specialized sub-agents" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn6esqvc0ed123c2wmg", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.380447Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of trying to handle everything in one prompt or workflow, create separate agents for specific tasks (like their headline agent vs. description agent). This makes debugging easier and improves output quality when dealing with complex requirements. Instead of trying to handle everything in one prompt or workflow, create separate agents for specific tasks (like their headline agent vs. description agent). This makes debugging easier and improves output quality when dealing with complex requirements." + }, + "annotations": {}, + "plain_text": "Instead of trying to handle everything in one prompt or workflow, create separate agents for specific tasks (like their headline agent vs. description agent). This makes debugging easier and improves output quality when dealing with complex requirements. Instead of trying to handle everything in one prompt or workflow, create separate agents for specific tasks (like their headline agent vs. description agent). This makes debugging easier and improves output quality when dealing with complex requirements." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn7f5n8cjzt0y4y1sbd", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.380667Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Thoroughly brainstorm and prompt plan before coding " + }, + "annotations": {}, + "plain_text": "Thoroughly brainstorm and prompt plan before coding " + }, + { + "type": "text", + "text": { + "content": "Thoroughly brainstorm and prompt plan before coding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Thoroughly brainstorm and prompt plan before coding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyn8fkb925jhd71h8093", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.380833Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 16 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Spend significant time upfront using Claude.ai to think through your entire workflow, then have Claude.ai create a comprehensive prompt and code structure for Claude Code to reference. Also, work step-by-step rather than asking for one-shot solutions to avoid Claude getting overwhelmed by complex tasks. Spend significant time upfront using Claude.ai to think through your entire workflow, then have Claude.ai create a comprehensive prompt and code structure for Claude Code to reference. Also, work step-by-step rather than asking for one-shot solutions to avoid Claude getting overwhelmed by complex tasks." + }, + "annotations": {}, + "plain_text": "Spend significant time upfront using Claude.ai to think through your entire workflow, then have Claude.ai create a comprehensive prompt and code structure for Claude Code to reference. Also, work step-by-step rather than asking for one-shot solutions to avoid Claude getting overwhelmed by complex tasks. Spend significant time upfront using Claude.ai to think through your entire workflow, then have Claude.ai create a comprehensive prompt and code structure for Claude Code to reference. Also, work step-by-step rather than asking for one-shot solutions to avoid Claude getting overwhelmed by complex tasks." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynafgst2v7d1nn1cj3w", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.385770Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": " Claude Code for product design " + }, + "annotations": {}, + "plain_text": " Claude Code for product design " + }, + { + "type": "text", + "text": { + "content": "Claude Code for product design" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for product design" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynbfyr9ypftj8f5wn6e", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.386279Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "The Product Design team supports Claude Code, Claude.ai and the Anthropic API, specializing in building AI products. Even non-developers can use Claude Code to bridge the traditional gap between design and engineering, enabling direct implementation of their design vision without extensive back-and-forth with engineers. The Product Design team supports Claude Code, Claude.ai and the Anthropic " + }, + "annotations": {}, + "plain_text": "The Product Design team supports Claude Code, Claude.ai and the Anthropic API, specializing in building AI products. Even non-developers can use Claude Code to bridge the traditional gap between design and engineering, enabling direct implementation of their design vision without extensive back-and-forth with engineers. The Product Design team supports Claude Code, Claude.ai and the Anthropic " + }, + { + "type": "text", + "text": { + "content": "API," + }, + "annotations": { + "bold": true + }, + "plain_text": "API," + }, + { + "type": "text", + "text": { + "content": " specializing in building Al products. Even non-developers can use Claude Code to bridge the traditional gap between design and engineering, enabling direct implementation of their design vision without extensive back-and-forth with engineers. " + }, + "annotations": {}, + "plain_text": " specializing in building Al products. Even non-developers can use Claude Code to bridge the traditional gap between design and engineering, enabling direct implementation of their design vision without extensive back-and-forth with engineers. " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyncfay9rbvdmm8zp0er", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.386412Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": {}, + "plain_text": "Main Claude Code use cases" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynde2yr1y44fkd7bdf6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.386633Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Front-end polish and state management changes " + }, + "annotations": {}, + "plain_text": "Front-end polish and state management changes " + }, + { + "type": "text", + "text": { + "content": "Front-end polish and state management changes" + }, + "annotations": { + "bold": true + }, + "plain_text": "Front-end polish and state management changes" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynefgxavtc6en71ss0n", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.386810Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Instead of creating extensive design documentation and going through multiple rounds of feedback with engineers for visual tweaks (typefaces, colors, spacing), they now directly implement these changes using Claude Code. Engineers noted they're making \"large state management changes that you typically wouldn't see a designer making,\" enabling them to achieve the exact quality they envision. Instead of creating extensive design documentation and going through multiple rounds of feedback with engineers for visual tweaks (typefaces, colors, spacing), they now directly implement these changes using Claude Code. Engineers noted they're making \"large state management changes that you typically wouldn't see a designer making,\" enabling them to achieve the exact quality they envision." + }, + "annotations": {}, + "plain_text": "Instead of creating extensive design documentation and going through multiple rounds of feedback with engineers for visual tweaks (typefaces, colors, spacing), they now directly implement these changes using Claude Code. Engineers noted they're making \"large state management changes that you typically wouldn't see a designer making,\" enabling them to achieve the exact quality they envision. Instead of creating extensive design documentation and going through multiple rounds of feedback with engineers for visual tweaks (typefaces, colors, spacing), they now directly implement these changes using Claude Code. Engineers noted they're making \"large state management changes that you typically wouldn't see a designer making,\" enabling them to achieve the exact quality they envision." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynffasrrest0wt8xe5k", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.387047Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "GitHub Actions automated ticketing " + }, + "annotations": {}, + "plain_text": "GitHub Actions automated ticketing " + }, + { + "type": "text", + "text": { + "content": "GitHub Actions automated ticketing" + }, + "annotations": { + "bold": true + }, + "plain_text": "GitHub Actions automated ticketing" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyngf7dr7g7e2724467d", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.387211Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Using Claude Code's GitHub integration, they can simply file issues/ tickets describing needed changes, and Claude automatically proposes code solutions without having to open Claude Code, creating a seamless bug-fixing and feature refinement workflow for their persistent backlog of polish tasks. Using Claude Code's GitHub integration, they can simply file issues/ tickets describing needed changes, and Claude automatically proposes code solutions without having to open Claude Code, creating a seamless bug-fixing and feature refinement workflow for their persistent backlog of polish tasks." + }, + "annotations": {}, + "plain_text": "Using Claude Code's GitHub integration, they can simply file issues/ tickets describing needed changes, and Claude automatically proposes code solutions without having to open Claude Code, creating a seamless bug-fixing and feature refinement workflow for their persistent backlog of polish tasks. Using Claude Code's GitHub integration, they can simply file issues/ tickets describing needed changes, and Claude automatically proposes code solutions without having to open Claude Code, creating a seamless bug-fixing and feature refinement workflow for their persistent backlog of polish tasks." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynhf8dtq7yagnaxxgw0", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.387433Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Rapid interactive prototyping " + }, + "annotations": {}, + "plain_text": "Rapid interactive prototyping " + }, + { + "type": "text", + "text": { + "content": "Rapid interactive prototyping" + }, + "annotations": { + "bold": true + }, + "plain_text": "Rapid interactive prototyping" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynjff08an3h904sjtx0", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.387592Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "By pasting mockup images into Claude Code, they generate fully functional prototypes that engineers can immediately understand and iterate on, replacing the traditional cycle of static Figma designs that required extensive explanation and translation to working code. By pasting mockup images into Claude Code, they generate fully functional prototypes that engineers can immediately understand and iterate on, replacing the traditional cycle of static Figma designs that required extensive explanation and translation to working code." + }, + "annotations": {}, + "plain_text": "By pasting mockup images into Claude Code, they generate fully functional prototypes that engineers can immediately understand and iterate on, replacing the traditional cycle of static Figma designs that required extensive explanation and translation to working code. By pasting mockup images into Claude Code, they generate fully functional prototypes that engineers can immediately understand and iterate on, replacing the traditional cycle of static Figma designs that required extensive explanation and translation to working code." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynkeegvhh1k8pf507yv", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.387812Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Edge case discovery and system architecture understanding " + }, + "annotations": {}, + "plain_text": "Edge case discovery and system architecture understanding " + }, + { + "type": "text", + "text": { + "content": "Edge case discovery and system architecture understanding" + }, + "annotations": { + "bold": true + }, + "plain_text": "Edge case discovery and system architecture understanding" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynmfy7rqr8v1mprwhw9", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.387968Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They use Claude Code to map out error states, logic flows, and different system statuses, allowing them to identify edge cases during design rather than discovering them later in development, fundamentally improving the quality of their initial designs. They use Claude Code to map out error states, logic flows, and different system statuses, allowing them to identify edge cases during design rather than discovering them later in development, fundamentally improving the quality of their initial designs." + }, + "annotations": {}, + "plain_text": "They use Claude Code to map out error states, logic flows, and different system statuses, allowing them to identify edge cases during design rather than discovering them later in development, fundamentally improving the quality of their initial designs. They use Claude Code to map out error states, logic flows, and different system statuses, allowing them to identify edge cases during design rather than discovering them later in development, fundamentally improving the quality of their initial designs." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynneqwrqbs6hjs9bns2", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.388195Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Complex copy changes and legal compliance " + }, + "annotations": {}, + "plain_text": "Complex copy changes and legal compliance " + }, + { + "type": "text", + "text": { + "content": "Complex copy changes and legal compliance" + }, + "annotations": { + "bold": true + }, + "plain_text": "Complex copy changes and legal compliance" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynpexgv5x7h3t1sfhrn", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.388380Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 17 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "For tasks like removing \"research preview\" messaging across the entire codebase, they used Claude Code to find all instances, review surrounding copy, coordinate changes with legal in real-time, and implement updates a process that took two 30-minute calls instead of a week of back-andforth coordination. For tasks like removing \"research preview\" messaging across the entire code base, they used Claude Code to find all instances, review surrounding copy, coordinate changes with legal in real-time, and implement updates a process that took two 30-minute calls instead of a week ofback-andforth coordination." + }, + "annotations": {}, + "plain_text": "For tasks like removing \"research preview\" messaging across the entire codebase, they used Claude Code to find all instances, review surrounding copy, coordinate changes with legal in real-time, and implement updates a process that took two 30-minute calls instead of a week of back-andforth coordination. For tasks like removing \"research preview\" messaging across the entire code base, they used Claude Code to find all instances, review surrounding copy, coordinate changes with legal in real-time, and implement updates a process that took two 30-minute calls instead of a week ofback-andforth coordination." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynreyta6atssmbprsm5", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.393106Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code for product design " + }, + "annotations": {}, + "plain_text": "Claude Code for product design " + }, + { + "type": "text", + "text": { + "content": "Claude Code for product design" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for product design" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynsfg38w8bfy6hqway0", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.393348Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team impact" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyntfn187hx2t03w4n4m", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.393559Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Team impact Transformed core workflow " + }, + "annotations": {}, + "plain_text": "Team impact Transformed core workflow " + }, + { + "type": "text", + "text": { + "content": "Transformed core workflow" + }, + "annotations": { + "bold": true + }, + "plain_text": "Transformed core workflow" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynvf76swrz75rmtjzep", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.393692Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Claude Code becomes a primary design tool, with Figma and Claude Code open 80% of the time. Claude Code becomes a primary design tool, with Figma and Claude Code open 80% of the time." + }, + "annotations": {}, + "plain_text": "Claude Code becomes a primary design tool, with Figma and Claude Code open 80% of the time. Claude Code becomes a primary design tool, with Figma and Claude Code open 80% of the time." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynwekrrc736rft9qgg7", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.393912Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_3": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "2-3x faster execution " + }, + "annotations": {}, + "plain_text": "2-3x faster execution " + }, + { + "type": "text", + "text": { + "content": "2-3x faster execution" + }, + "annotations": { + "bold": true + }, + "plain_text": "2-3x faster execution" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynxfp5akvwh92ggtrhy", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.394057Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Visual and state management changes that previously required extensive back-and-forth with engineers now implemented directly. Visual and state management changes that previously required extensive back-and-forth with engineers now implemented directly." + }, + "annotations": {}, + "plain_text": "Visual and state management changes that previously required extensive back-and-forth with engineers now implemented directly. Visual and state management changes that previously required extensive back-and-forth with engineers now implemented directly." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynyf63sx1r6wzq9peet", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.394360Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Weeks to hours cycle time " + }, + "annotations": {}, + "plain_text": "Weeks to hours cycle time " + }, + { + "type": "text", + "text": { + "content": "Weeks to hours cycle time" + }, + "annotations": { + "bold": true + }, + "plain_text": "Weeks to hours cycle time" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvynzfxt8qq7r0wvby35y", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.394499Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Complex projects like GA launch messaging that would take a week of coordination now completed in two 30-minute calls. Complex projects like GA launch messaging that would take a week of coordination now completed in two 30-minute calls." + }, + "annotations": {}, + "plain_text": "Complex projects like GA launch messaging that would take a week of coordination now completed in two 30-minute calls. Complex projects like GA launch messaging that would take a week of coordination now completed in two 30-minute calls." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp0fgxtha6wpc4tg4yz", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.394715Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Two distinct user experiences " + }, + "annotations": {}, + "plain_text": "Two distinct user experiences " + }, + { + "type": "text", + "text": { + "content": "Two distinct user experiences" + }, + "annotations": { + "bold": true + }, + "plain_text": "Two distinct user experiences" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp1ec5sd25jd88nvfg1", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.394853Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Developers get \"augmented workflow\" (faster execution), while nontechnical users get \"holy crap, I'm a developer workflow\" (entirely new capabilities previously impossible). Developers get \"augmented workflow\" (faster execution), while nontechnical users get \"holy crap, I'm a developer workflow\" ( entirely new capabilities previously impossible)." + }, + "annotations": {}, + "plain_text": "Developers get \"augmented workflow\" (faster execution), while nontechnical users get \"holy crap, I'm a developer workflow\" (entirely new capabilities previously impossible). Developers get \"augmented workflow\" (faster execution), while nontechnical users get \"holy crap, I'm a developer workflow\" ( entirely new capabilities previously impossible)." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp2f7cab7es335q2ahz", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.395077Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Improved design-engineering collaboration " + }, + "annotations": {}, + "plain_text": "Improved design-engineering collaboration " + }, + { + "type": "text", + "text": { + "content": "Improved design-engineering collaboration" + }, + "annotations": { + "bold": true + }, + "plain_text": "Improved design-engineering collaboration" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp3ehdsgj0q2771dqq0", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.395207Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Better communication and faster problem-solving because designers understand system constraints and possibilities upfront. Better communication and faster problem-solving because designers understand system constraints and possibilities upfront." + }, + "annotations": {}, + "plain_text": "Better communication and faster problem-solving because designers understand system constraints and possibilities upfront. Better communication and faster problem-solving because designers understand system constraints and possibilities upfront." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp4f5gr7m3zvk5wqzs8", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.395427Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_1": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the Product Design team " + }, + "annotations": {}, + "plain_text": "Top tips from the Product Design team " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Product Design team" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Product Design team" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp5eg9rtap0gf88fame", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.395645Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Get proper setup help from engineers " + }, + "annotations": {}, + "plain_text": "Get proper setup help from engineers " + }, + { + "type": "text", + "text": { + "content": "Get proper setup help from engineers" + }, + "annotations": { + "bold": true + }, + "plain_text": "Get proper setup help from engineers" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp6ergrr1jc6vqc2m2v", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.395790Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Have engineering teammates help with initial repository setup and permissions - the technical onboarding is challenging for non-developers, but once configured, it becomes transformative for daily workflow. Have engineering teammates help with initial repository setup and permissions - the technical onboarding is challenging for non-developers, but once configured, it becomes transformative for daily workflow." + }, + "annotations": {}, + "plain_text": "Have engineering teammates help with initial repository setup and permissions - the technical onboarding is challenging for non-developers, but once configured, it becomes transformative for daily workflow. Have engineering teammates help with initial repository setup and permissions - the technical onboarding is challenging for non-developers, but once configured, it becomes transformative for daily workflow." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp7eaks9x6w7y5adfxq", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.396012Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use custom memory files to guide Claude's behavior " + }, + "annotations": {}, + "plain_text": "Use custom memory files to guide Claude's behavior " + }, + { + "type": "text", + "text": { + "content": "Use custom memory files to guide Claude's behavior" + }, + "annotations": { + "bold": true + }, + "plain_text": "Use custom memory files to guide Claude's behavior" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp8ec29f57rmbq7rmeq", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.396167Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Create specific instructions telling Claude you're a designer with little coding experience who needs detailed explanations and smaller, incremental changes, dramatically improving the quality of Claude's responses and making it less intimidating. Create specific instructions telling Claude you're a designer with little coding experience who needs detailed explanations and smaller, incremental changes, dramatically improving the quality of Claude's responses and making it less intimidating." + }, + "annotations": {}, + "plain_text": "Create specific instructions telling Claude you're a designer with little coding experience who needs detailed explanations and smaller, incremental changes, dramatically improving the quality of Claude's responses and making it less intimidating. Create specific instructions telling Claude you're a designer with little coding experience who needs detailed explanations and smaller, incremental changes, dramatically improving the quality of Claude's responses and making it less intimidating." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyp9fbys7szashj4arzq", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.396409Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 + } + }, + "heading_2": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Leverage image pasting for prototyping " + }, + "annotations": {}, + "plain_text": "Leverage image pasting for prototyping " }, - "plain_text": "Test document", - "href": null + { + "type": "text", + "text": { + "content": "Leverage image pasting for prototyping" + }, + "annotations": { + "bold": true + }, + "plain_text": "Leverage image pasting for prototyping" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypaf8nrajee9yztnkrw", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.396568Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 18 } - ] - } - }, - "children": [ + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Use Command+V to paste screenshots directly into Claude Code - it excels at reading designs and generating functional code, making it invaluable for turning static mockups into interactive prototypes that engineers can immediately understand and build upon. Use Command+V to paste screenshots directly into Claude Code - it excels at reading designs and generating functional code, making it invaluable for turning static mockups into interactive prototypes that engineers can immediately understand and build upon." + }, + "annotations": {}, + "plain_text": "Use Command+V to paste screenshots directly into Claude Code - it excels at reading designs and generating functional code, making it invaluable for turning static mockups into interactive prototypes that engineers can immediately understand and build upon. Use Command+V to paste screenshots directly into Claude Code - it excels at reading designs and generating functional code, making it invaluable for turning static mockups into interactive prototypes that engineers can immediately understand and build upon." + } + ] + } + }, { "object": "block", - "id": "026ad4b3-068c-49a7-a036-c734f8ede2d7", + "id": "bk_01jxwgvypcezrtjdgdzdwpg1g9", "type": "heading_1", - "created_time": "2025-06-02T15:20:59.534143Z", + "created_time": "2025-06-16T14:04:08.401757Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "HTML QA Test Page" }, + "text": { + "content": " Claude Code for RL engineering " + }, "annotations": {}, - "plain_text": "HTML QA Test Page" + "plain_text": " Claude Code for RL engineering " + }, + { + "type": "text", + "text": { + "content": "Claude Code for RL engineering" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for RL engineering" } ] } }, { "object": "block", - "id": "4b66544c-a084-4e99-8336-735687929f16", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535160Z", + "id": "bk_01jxwgvypde1pbph9ym2hgtj95", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.402058Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Text", "link": { "url": "#text" } }, + "text": { + "content": "The RL Engineering team focuses on efficient sampling in RL and weight transfers across the cluster. They use Claude Code primarily for writing small to medium features, debugging, and understanding complex codebases, with an iterative approach that includes frequent checkpointing and rollbacks. The RL Engineering team focuses on efficient sampling in RL and weight transfers across the cluster. They use Claude Code primarily for writing small to medium features, debugging, and understanding complex codebases, with an iterative approach that includes frequent checkpointing and rollbacks. " + }, "annotations": {}, - "plain_text": "Text", - "href": "#text" + "plain_text": "The RL Engineering team focuses on efficient sampling in RL and weight transfers across the cluster. They use Claude Code primarily for writing small to medium features, debugging, and understanding complex codebases, with an iterative approach that includes frequent checkpointing and rollbacks. The RL Engineering team focuses on efficient sampling in RL and weight transfers across the cluster. They use Claude Code primarily for writing small to medium features, debugging, and understanding complex codebases, with an iterative approach that includes frequent checkpointing and rollbacks. " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" } ] } }, { "object": "block", - "id": "e55439da-b02d-4483-b6b3-d8216f16ec61", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535230Z", + "id": "bk_01jxwgvypeevmb2wkzpy8t69j2", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.402176Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "Lists & Tables", - "link": { "url": "#lists-tables" } + "content": "Main Claude Code use cases" }, "annotations": {}, - "plain_text": "Lists & Tables", - "href": "#lists-tables" + "plain_text": "Main Claude Code use cases" } ] } }, { "object": "block", - "id": "834fac7e-1b57-47f3-99e3-2811db0ace32", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535274Z", + "id": "bk_01jxwgvypfe8gvvjbyj118jcbq", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.402401Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Media", "link": { "url": "#media" } }, + "text": { + "content": "Feature development with supervised autonomy " + }, "annotations": {}, - "plain_text": "Media", - "href": "#media" + "plain_text": "Feature development with supervised autonomy " + }, + { + "type": "text", + "text": { + "content": "Feature development with supervised autonomy" + }, + "annotations": { + "bold": true + }, + "plain_text": "Feature development with supervised autonomy" } ] } }, { "object": "block", - "id": "596289db-3b11-4352-9815-920ec4cd7097", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535315Z", + "id": "bk_01jxwgvypgf9tt2xwz6j523xhv", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.402567Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "paragraph": { "rich_text": [ { "type": "text", "text": { - "content": "Multi-Column", - "link": { "url": "#multi-column" } + "content": "The team lets Claude Code write most of the code for small to medium features while providing oversight, such as implementing authentication mechanisms for weight transfer components. They work interactively, allowing Claude to take the lead but steering it when it goes off track. The team lets Claude Code write most of the code for small to medium features while providing oversight, such as implementing authentication mechanisms for weight transfer components. They work interactively, allowing Claude to take the lead but steering it when it goes off track." }, "annotations": {}, - "plain_text": "Multi-Column", - "href": "#multi-column" + "plain_text": "The team lets Claude Code write most of the code for small to medium features while providing oversight, such as implementing authentication mechanisms for weight transfer components. They work interactively, allowing Claude to take the lead but steering it when it goes off track. The team lets Claude Code write most of the code for small to medium features while providing oversight, such as implementing authentication mechanisms for weight transfer components. They work interactively, allowing Claude to take the lead but steering it when it goes off track." } ] } }, { "object": "block", - "id": "2188f7cb-edc1-422f-9114-8701b9cd989d", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535347Z", + "id": "bk_01jxwgvyphfa3s8v0haz2xta0d", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.402787Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_3": { "rich_text": [ { "type": "text", - "text": { "content": "Code", "link": { "url": "#code" } }, + "text": { + "content": "Test generation and code review " + }, "annotations": {}, - "plain_text": "Code", - "href": "#code" + "plain_text": "Test generation and code review " + }, + { + "type": "text", + "text": { + "content": "Test generation and code review" + }, + "annotations": { + "bold": true + }, + "plain_text": "Test generation and code review" } ] } }, { "object": "block", - "id": "692ae263-8898-4e32-8d85-0ec168d1d9f7", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.535377Z", + "id": "bk_01jxwgvypjechtkdf80qxcc8a0", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.402939Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Forms", "link": { "url": "#form" } }, + "text": { + "content": "After implementing changes themselves, they ask Claude Code to add tests or review their code. This automated testing workflow saves significant time on routine but important quality assurance tasks. After implementing changes themselves, they ask Claude Code to add tests or review their code. This automated testing workflow saves significant time on routine but important quality assurance tasks." + }, "annotations": {}, - "plain_text": "Forms", - "href": "#form" + "plain_text": "After implementing changes themselves, they ask Claude Code to add tests or review their code. This automated testing workflow saves significant time on routine but important quality assurance tasks. After implementing changes themselves, they ask Claude Code to add tests or review their code. This automated testing workflow saves significant time on routine but important quality assurance tasks." } ] } }, { "object": "block", - "id": "1f1c61e7-e4d1-4b11-81cd-3e9f8fdd371e", - "type": "heading_2", - "created_time": "2025-06-02T15:20:59.535555Z", + "id": "bk_01jxwgvypkeyr9g59d2pk4crze", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.403165Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_2": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_3": { "rich_text": [ { "type": "text", - "text": { "content": "Text Elements" }, + "text": { + "content": "Debugging and error investigation " + }, "annotations": {}, - "plain_text": "Text Elements" + "plain_text": "Debugging and error investigation " + }, + { + "type": "text", + "text": { + "content": "Debugging and error investigation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Debugging and error investigation" } ] } }, { "object": "block", - "id": "33fa8590-a4ff-4db2-8d13-e587741aa495", + "id": "bk_01jxwgvypmfh4r869bkehdxnf9", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.535994Z", + "created_time": "2025-06-16T14:04:08.403344Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "This is a " }, + "text": { + "content": "They use Claude Code to debug errors with mixed results - sometimes it identifies issues immediately and adds relevant tests, while other times it struggles to understand the problem, but overall provides value when it works. They use Claude Code to debug errors with mixed results - sometimes it identifies issues immediately and adds relevant tests, while other times it struggles to understand the problem, but overall provides value when it works." + }, "annotations": {}, - "plain_text": "This is a " - }, + "plain_text": "They use Claude Code to debug errors with mixed results - sometimes it identifies issues immediately and adds relevant tests, while other times it struggles to understand the problem, but overall provides value when it works. They use Claude Code to debug errors with mixed results - sometimes it identifies issues immediately and adds relevant tests, while other times it struggles to understand the problem, but overall provides value when it works." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypnf5tth2g38byvwyd5", + "type": "heading_3", + "created_time": "2025-06-16T14:04:08.403677Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_3": { + "rich_text": [ { "type": "text", - "text": { "content": "paragraph" }, - "annotations": { "bold": true }, - "plain_text": "paragraph" + "text": { + "content": "Codebase comprehension and call stack analysis " + }, + "annotations": {}, + "plain_text": "Codebase comprehension and call stack analysis " }, { "type": "text", - "text": { "content": " with " }, - "annotations": {}, - "plain_text": " with " - }, + "text": { + "content": "Codebase comprehension and call stack analysis" + }, + "annotations": { + "bold": true + }, + "plain_text": "Codebase comprehension and call stack analysis" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvyppe3d985a7p27xh14y", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.403835Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "paragraph": { + "rich_text": [ { "type": "text", - "text": { "content": "emphasis" }, - "annotations": { "italic": true }, - "plain_text": "emphasis" - }, + "text": { + "content": "One of the biggest changes in their workflow is using Claude Code to get quick summaries of relevant components and call stacks, replacing manual code reading or extensive debugging output generation. One of the biggest changes in their workflow is using Claude Code to get quick summaries of relevant components and call stacks, replacing manual code reading or extensive debugging output generation." + }, + "annotations": {}, + "plain_text": "One of the biggest changes in their workflow is using Claude Code to get quick summaries of relevant components and call stacks, replacing manual code reading or extensive debugging output generation. One of the biggest changes in their workflow is using Claude Code to get quick summaries of relevant components and call stacks, replacing manual code reading or extensive debugging output generation." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypqe9ctamxrrn6nkps3", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.404066Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "heading_1": { + "rich_text": [ { "type": "text", - "text": { "content": ", underline, and " }, + "text": { + "content": "Kubernetes operations guidance " + }, "annotations": {}, - "plain_text": ", underline, and " + "plain_text": "Kubernetes operations guidance " }, { "type": "text", - "text": { "content": ", underline, and " }, + "text": { + "content": "Kubernetes operations guidance" + }, + "annotations": { + "bold": true + }, + "plain_text": "Kubernetes operations guidance" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypre8sa9twc37qvnc8z", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.404210Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 19 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "They frequently ask Claude Code about Kubernetes operations that would otherwise require extensive Googling, getting immediate answers for configuration and deployment questions. They frequently ask Claude Code about Kubemetes operations that would otherwise require extensive Googling, getting immediate answers for configuration and deployment questions." + }, "annotations": {}, - "plain_text": ", underline, and " - }, + "plain_text": "They frequently ask Claude Code about Kubernetes operations that would otherwise require extensive Googling, getting immediate answers for configuration and deployment questions. They frequently ask Claude Code about Kubemetes operations that would otherwise require extensive Googling, getting immediate answers for configuration and deployment questions." + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypteqzv7py0k1hftgdz", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.408759Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { + "rich_text": [ { "type": "text", - "text": { "content": ", underline, and " }, + "text": { + "content": "Claude Code for RL engineering " + }, "annotations": {}, - "plain_text": ", underline, and " + "plain_text": "Claude Code for RL engineering " }, { "type": "text", - "text": { "content": "inline code" }, - "annotations": { "code": true }, - "plain_text": "inline code" - }, + "text": { + "content": "Claude Code for RL engineering" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for RL engineering" + } + ] + } + }, + { + "object": "block", + "id": "bk_01jxwgvypvecpamrq8bzbezqvj", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.409009Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { + "rich_text": [ { "type": "text", - "text": { "content": "." }, + "text": { + "content": "Development workflow impact " + }, "annotations": {}, - "plain_text": "." + "plain_text": "Development workflow impact " + }, + { + "type": "text", + "text": { + "content": "Development workflow impact" + }, + "annotations": { + "bold": true + }, + "plain_text": "Development workflow impact" } ] } }, { "object": "block", - "id": "93866e62-95e3-45dd-b0ec-23cf8db9fd24", - "type": "quote", - "created_time": "2025-06-02T15:20:59.536081Z", + "id": "bk_01jxwgvypwfwvbxq7rntmve351", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.409131Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "quote": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "\"This is a blockquote for testing.\"" }, + "text": { + "content": "Top tips from the" + }, "annotations": {}, - "plain_text": "\"This is a blockquote for testing.\"" + "plain_text": "Top tips from the" } ] } }, { "object": "block", - "id": "5525f86f-76a2-4a65-b607-08f8b4848d36", - "type": "divider", - "created_time": "2025-06-02T15:20:59.536130Z", + "id": "bk_01jxwgvypxe0y9r7cg9p011026", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.409349Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "divider": {} + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { + "rich_text": [ + { + "type": "text", + "text": { + "content": "Top tips from the" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the" + } + ] + } }, { "object": "block", - "id": "29b88ddf-a907-4259-98dc-5feac25553fd", - "type": "heading_2", - "created_time": "2025-06-02T15:20:59.536171Z", + "id": "bk_01jxwgvypyehesaf3qfjmcmr3z", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.409448Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_2": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Lists & Tables" }, + "text": { + "content": "RL Engineering team" + }, "annotations": {}, - "plain_text": "Lists & Tables" + "plain_text": "RL Engineering team" } ] } }, { "object": "block", - "id": "746a6771-7234-40a9-8bf7-16249f400ff0", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.536205Z", + "id": "bk_01jxwgvypzf1wvxem27mmsyn4d", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.409659Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Unordered List" }, - "annotations": {}, - "plain_text": "Unordered List" + "text": { + "content": "RL Engineering team" + }, + "annotations": { + "bold": true + }, + "plain_text": "RL Engineering team" } ] } }, { "object": "block", - "id": "564201a0-1bdc-4312-8235-e19b2af794a9", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.536257Z", + "id": "bk_01jxwgvyq0ff18m10svkbjjfkn", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.409860Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Apple" }, + "text": { + "content": "Experimental approach enabled " + }, "annotations": {}, - "plain_text": "Apple" + "plain_text": "Experimental approach enabled " + }, + { + "type": "text", + "text": { + "content": "Experimental approach enabled" + }, + "annotations": { + "bold": true + }, + "plain_text": "Experimental approach enabled" } ] } }, { "object": "block", - "id": "3aaadb89-ccdb-4098-9d8f-32061b4b179c", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.536286Z", + "id": "bk_01jxwgvyq1e55vry8fsspn5n35", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.410014Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Banana" }, + "text": { + "content": "They now use a \"try and rollback\" methodology, frequently committing checkpoints so they can test Claude's autonomous implementation attempts and revert if needed, enabling more experimental. They now use a \"try and rollback\" methodology, frequently committing checkpoints so they can test Claude's autonomous implementation attempts and revert if needed, enabling more experimental." + }, "annotations": {}, - "plain_text": "Banana" + "plain_text": "They now use a \"try and rollback\" methodology, frequently committing checkpoints so they can test Claude's autonomous implementation attempts and revert if needed, enabling more experimental. They now use a \"try and rollback\" methodology, frequently committing checkpoints so they can test Claude's autonomous implementation attempts and revert if needed, enabling more experimental." } ] } }, { "object": "block", - "id": "35a670f2-1ef5-4e88-adb8-3d435908e124", - "type": "bulleted_list_item", - "created_time": "2025-06-02T15:20:59.536312Z", + "id": "bk_01jxwgvyq2e6rr6vteja2z555k", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.410231Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "bulleted_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_2": { "rich_text": [ { "type": "text", - "text": { "content": "Cherry" }, + "text": { + "content": "Documentation acceleration " + }, "annotations": {}, - "plain_text": "Cherry" + "plain_text": "Documentation acceleration " + }, + { + "type": "text", + "text": { + "content": "Documentation acceleration" + }, + "annotations": { + "bold": true + }, + "plain_text": "Documentation acceleration" } ] } }, { "object": "block", - "id": "e413b638-3517-46f9-8d94-594c27e2bb41", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.536370Z", + "id": "bk_01jxwgvyq3er3v9fhspf7155wk", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.410381Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Ordered List" }, + "text": { + "content": "Claude Code automatically adds helpful comments that save significant time on documentation, though they note it sometimes adds comments in odd places or uses questionable code organization. Claude Code automatically adds helpful comments that save significant time on documentation, though they note it sometimes adds comments in odd places or uses questionable code organization." + }, "annotations": {}, - "plain_text": "Ordered List" + "plain_text": "Claude Code automatically adds helpful comments that save significant time on documentation, though they note it sometimes adds comments in odd places or uses questionable code organization. Claude Code automatically adds helpful comments that save significant time on documentation, though they note it sometimes adds comments in odd places or uses questionable code organization." } ] } }, { "object": "block", - "id": "f814a085-ebb6-48d9-8fc5-7edf280f3e14", - "type": "numbered_list_item", - "created_time": "2025-06-02T15:20:59.536443Z", + "id": "bk_01jxwgvyq4f8sapab8cfwasjkb", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.410599Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "numbered_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "Here is a quote\nSome ", - "link": null - }, - "annotations": { - "bold": false, - "italic": false, - "strikethrough": false, - "underline": false, - "code": false, - "color": "default" - }, - "plain_text": "Here is a quote\nSome ", - "href": null - }, - { - "type": "text", - "text": { - "content": "formatted text", - "link": null - }, - "annotations": { - "bold": true, - "italic": false, - "strikethrough": false, - "underline": false, - "code": false, - "color": "default" + "content": "Speed-up with limitations " }, - "plain_text": "formatted text", - "href": null + "annotations": {}, + "plain_text": "Speed-up with limitations " }, { "type": "text", "text": { - "content": " inside the quote", - "link": null + "content": "Speed-up with limitations" }, "annotations": { - "bold": false, - "italic": false, - "strikethrough": false, - "underline": false, - "code": false, - "color": "default" + "bold": true }, - "plain_text": " inside the quote", - "href": null + "plain_text": "Speed-up with limitations" } ] } }, { "object": "block", - "id": "f2f4e5fe-fe60-42f0-9baa-dbbd8c57dc10", - "type": "numbered_list_item", - "created_time": "2025-06-02T15:20:59.536487Z", + "id": "bk_01jxwgvyq5e4jrzyyjea2r6gyy", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.410751Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "numbered_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Beta" }, + "text": { + "content": "While Claude Code can implement small-to-medium PRs with \"relatively little time\" from them, they acknowledge it only works on first attempt about one-third of the time, requiring either additional guidance or manual intervention. While Claude Code can implement small-to-medium PRs with \"relatively little time\" from them, they acknowledge it only works on first attempt about one-third of the time, requiring either additional guidance or manual intervention." + }, "annotations": {}, - "plain_text": "Beta" + "plain_text": "While Claude Code can implement small-to-medium PRs with \"relatively little time\" from them, they acknowledge it only works on first attempt about one-third of the time, requiring either additional guidance or manual intervention. While Claude Code can implement small-to-medium PRs with \"relatively little time\" from them, they acknowledge it only works on first attempt about one-third of the time, requiring either additional guidance or manual intervention." } ] } }, { "object": "block", - "id": "190349d0-60d1-474a-939d-5f77c9dc4cc4", - "type": "numbered_list_item", - "created_time": "2025-06-02T15:20:59.536513Z", + "id": "bk_01jxwgvyq6f92vq3mjh296w9qf", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.410970Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "numbered_list_item": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Gamma" }, + "text": { + "content": "Customize your Claude.md file for specific patterns " + }, "annotations": {}, - "plain_text": "Gamma" + "plain_text": "Customize your Claude.md file for specific patterns " + }, + { + "type": "text", + "text": { + "content": "Customize your Claude.md file for specific patterns" + }, + "annotations": { + "bold": true + }, + "plain_text": "Customize your Claude.md file for specific patterns" } ] } }, { "object": "block", - "id": "6381f055-80ca-4d1b-9c2f-27def89529a9", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.536583Z", + "id": "bk_01jxwgvyq7f189t1sj3yn8bq1k", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.411135Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Table" }, + "text": { + "content": "Add instructions to your Claude.md file to prevent Claude from making repeated tool-calling mistakes, such as telling it to \"run pytest not run and don't cd unnecessarily - just use the right path.\" This significantly improved consistency. Add instructions to your Claude.md file to prevent Claude from making repeated tool-calling mistakes, such as telling it to \"run pytest not run and don't cd unnecessarily - just use the right path.\" This significantly improved consistency." + }, "annotations": {}, - "plain_text": "Table" + "plain_text": "Add instructions to your Claude.md file to prevent Claude from making repeated tool-calling mistakes, such as telling it to \"run pytest not run and don't cd unnecessarily - just use the right path.\" This significantly improved consistency. Add instructions to your Claude.md file to prevent Claude from making repeated tool-calling mistakes, such as telling it to \"run pytest not run and don't cd unnecessarily - just use the right path.\" This significantly improved consistency." } ] } }, { "object": "block", - "id": "72ab92c4-8ab8-4b78-8f1b-15269e7c9f33", - "type": "table", - "created_time": "2025-06-02T15:20:59.536874Z", - "table": { "has_column_header": true, "has_row_header": false }, - "children": [ - { - "object": "block", - "id": "09987e5b-2010-49da-8f89-0df66f809955", - "type": "table_row", - "created_time": "2025-06-02T15:20:59.536692Z", - "has_children": false, - "table_row": { - "cells": [ - [ - { - "type": "text", - "text": { "content": "Name" }, - "annotations": {}, - "plain_text": "Name" - } - ], - [ - { - "type": "text", - "text": { "content": "Role" }, - "annotations": {}, - "plain_text": "Role" - } - ] - ] - } - }, - { - "object": "block", - "id": "e64938b1-2966-4729-ad2e-4cb6765cab9d", - "type": "table_row", - "created_time": "2025-06-02T15:20:59.536777Z", - "has_children": false, - "table_row": { - "cells": [ - [ - { - "type": "text", - "text": { "content": "Alice" }, - "annotations": {}, - "plain_text": "Alice" - } - ], - [ - { - "type": "text", - "text": { "content": "Developer" }, - "annotations": {}, - "plain_text": "Developer" - } - ] - ] - } - }, - { - "object": "block", - "id": "af08d8f5-7bf1-4183-9d56-58cd1eae1108", - "type": "table_row", - "created_time": "2025-06-02T15:20:59.536840Z", - "has_children": false, - "table_row": { - "cells": [ - [ - { - "type": "text", - "text": { "content": "Bob" }, - "annotations": {}, - "plain_text": "Bob" - } - ], - [ - { - "type": "text", - "text": { "content": "Designer" }, - "annotations": {}, - "plain_text": "Designer" - } - ] - ] - } - } - ] - }, - { - "object": "block", - "id": "585889a4-e5b8-462d-ac65-9583161ac543", - "type": "divider", - "created_time": "2025-06-02T15:20:59.536915Z", - "has_children": false, - "divider": {} - }, - { - "object": "block", - "id": "6f7f7550-174c-4287-9124-b5143747114e", + "id": "bk_01jxwgvyq8fzrt7k0bfwwf8hx9", "type": "heading_2", - "created_time": "2025-06-02T15:20:59.536941Z", + "created_time": "2025-06-16T14:04:08.411358Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, "heading_2": { "rich_text": [ { "type": "text", - "text": { "content": "Images" }, + "text": { + "content": "Use a checkpoint-heavy workflow " + }, "annotations": {}, - "plain_text": "Images" - } - ] - } - }, - { - "object": "block", - "id": "0e141978-6b48-425f-8e65-7951c6f64077", - "type": "image", - "created_time": "2025-06-02T15:20:59.536985Z", - "image": { - "type": "external", - "external": { - "url": "https://images.unsplash.com/photo-1518770660439-4636190af475?w=400" - }, - "caption": [ + "plain_text": "Use a checkpoint-heavy workflow " + }, { "type": "text", "text": { - "content": "Image /page/1/Figure/3 description: The image shows a diagram of the Ultihash Ocean Tier architecture. The diagram is divided into three tiers: Tier 1 Cloud Hyperscaler, GPU Cloud, and Tier 2 Cloud e.g. EU provider. The Tier 1 Cloud Hyperscaler includes Google Cloud, AWS, and Azure. The GPU Cloud includes Lambda, Nebius, Salad, and RunPod. The Tier 2 Cloud e.g. EU provider includes OVHcloud, Hetzner, and GCore. The diagram also shows the Ultihash Ocean Tier, which includes 10 TiB Freemium, Ultihash self-hosted, and Ultihash serverless. The diagram also shows the benefits of the Ultihash Ocean Tier, which include zero-effort data access across clouds, no manual migration, smart orchestration of data placement, 10x lower latency, and 50% lower egress fees. The diagram also shows that the Ultihash Ocean Tier is Kubernetes-native object storage, has high throughput read performance, lossless deduplication cuts TCO by up to 60%, and is S3-compatible, deployable on-prem or cloud." + "content": "Use a checkpoint-heavy workflow" }, - "annotations": {}, - "plain_text": "Image /page/1/Figure/3 description: The image shows a diagram of the Ultihash Ocean Tier architecture. The diagram is divided into three tiers: Tier 1 Cloud Hyperscaler, GPU Cloud, and Tier 2 Cloud e.g. EU provider. The Tier 1 Cloud Hyperscaler includes Google Cloud, AWS, and Azure. The GPU Cloud includes Lambda, Nebius, Salad, and RunPod. The Tier 2 Cloud e.g. EU provider includes OVHcloud, Hetzner, and GCore. The diagram also shows the Ultihash Ocean Tier, which includes 10 TiB Freemium, Ultihash self-hosted, and Ultihash serverless. The diagram also shows the benefits of the Ultihash Ocean Tier, which include zero-effort data access across clouds, no manual migration, smart orchestration of data placement, 10x lower latency, and 50% lower egress fees. The diagram also shows that the Ultihash Ocean Tier is Kubernetes-native object storage, has high throughput read performance, lossless deduplication cuts TCO by up to 60%, and is S3-compatible, deployable on-prem or cloud." + "annotations": { + "bold": true + }, + "plain_text": "Use a checkpoint-heavy workflow" } ] } }, { "object": "block", - "id": "e333ac45-76cc-4e94-b7b7-dbe7ce6400d8", + "id": "bk_01jxwgvyq9ex9skmrc54495ghf", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537025Z", + "created_time": "2025-06-16T14:04:08.411503Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Person coding on laptop" }, + "text": { + "content": "Regularly commit your work as Claude makes changes so you can easily roll back when experiments don't work out. This enables a more experimental approach to development without risk. Regularly commit your work as Claude makes changes so you can easily roll back when experiments don't work out. This enables a more experimental approach to development without risk." + }, "annotations": {}, - "plain_text": "Person coding on laptop" + "plain_text": "Regularly commit your work as Claude makes changes so you can easily roll back when experiments don't work out. This enables a more experimental approach to development without risk. Regularly commit your work as Claude makes changes so you can easily roll back when experiments don't work out. This enables a more experimental approach to development without risk." } ] } }, { "object": "block", - "id": "7e896df2-88a7-48d8-a75e-8172ad68e88d", - "type": "image", - "created_time": "2025-06-02T15:20:59.537062Z", - "image": { - "type": "external", - "external": { - "url": "https://images.unsplash.com/photo-1555066931-4365d14bab8c?w=400" - } - } - }, - { - "object": "block", - "id": "6d83f023-0f10-4bca-a3aa-13d17e7a5c77", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537085Z", + "id": "bk_01jxwgvyqaepttkqj31cqwyzp0", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.411721Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Office desk with computer" }, + "text": { + "content": "Try one-shot first, then collaborate " + }, "annotations": {}, - "plain_text": "Office desk with computer" + "plain_text": "Try one-shot first, then collaborate " + }, + { + "type": "text", + "text": { + "content": "Try one-shot first, then collaborate" + }, + "annotations": { + "bold": true + }, + "plain_text": "Try one-shot first, then collaborate" } ] } }, { "object": "block", - "id": "ed8a3fff-c914-4277-84c4-cc8161e5fd2d", - "type": "image", - "created_time": "2025-06-02T15:20:59.537120Z", - "image": { - "type": "external", - "external": { - "url": "https://images.unsplash.com/photo-1504384308090-c894fdcc538d?w=400" - } - } - }, - { - "object": "block", - "id": "45cf8e9e-c869-41e3-9d24-47f8dc0a6fa1", + "id": "bk_01jxwgvyqbep5vv8r7vy6phyh5", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537145Z", + "created_time": "2025-06-16T14:04:08.411877Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 20 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Coffee and notebook" }, + "text": { + "content": "Give Claude a quick prompt and let it attempt the full implementation first. If it works (about one-third of the time), you've saved significant time. If not, then switch to a more collaborative, guided approach. Give Claude a quick prompt and let it attempt the full implementation first. Ifit works (about one-third of the time), you've saved significant time. If not, then switch to a more collaborative, guided approach. CLAUDE CODE FOR RL ENGINEERING" + }, "annotations": {}, - "plain_text": "Coffee and notebook" + "plain_text": "Give Claude a quick prompt and let it attempt the full implementation first. If it works (about one-third of the time), you've saved significant time. If not, then switch to a more collaborative, guided approach. Give Claude a quick prompt and let it attempt the full implementation first. Ifit works (about one-third of the time), you've saved significant time. If not, then switch to a more collaborative, guided approach. CLAUDE CODE FOR RL ENGINEERING" } ] } }, { "object": "block", - "id": "3b360430-d3f1-465c-b4a3-07ddc161b1c9", - "type": "divider", - "created_time": "2025-06-02T15:20:59.537179Z", - "has_children": false, - "divider": {} - }, - { - "object": "block", - "id": "bb0b2836-d5eb-4ad0-8ef1-ee83a87a4083", - "type": "heading_2", - "created_time": "2025-06-02T15:20:59.537212Z", + "id": "bk_01jxwgvyqde5xvqv1vpxfk0rjm", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.416681Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_2": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Multi-Column Content" }, + "text": { + "content": " Claude Code for legal " + }, "annotations": {}, - "plain_text": "Multi-Column Content" + "plain_text": " Claude Code for legal " + }, + { + "type": "text", + "text": { + "content": "Claude Code for legal" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for legal" } ] } }, { "object": "block", - "id": "600f1a9c-4426-437d-a825-2acfb72cda7d", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.537243Z", + "id": "bk_01jxwgvyqefy5apy9ckdr3yp0c", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.416865Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Flexbox Columns" }, + "text": { + "content": "The Legal team discovered Claude Code's potential through experimentation, and a desire to learn about Anthropic's product offerings. Additionally, one team member had a personal use case related to creating accessibility tools for family and work prototypes that demonstrate the technology's power for non-developers. The Legal team discovered Claude Code's potential through experimentation, and a desire to learn about Anthropic's product offerings. Additionally, one team member had a personal use case related to creating accessibility tools for fomily and work prototypes that demonstrate the technology's power for non-developers." + }, "annotations": {}, - "plain_text": "Flexbox Columns" + "plain_text": "The Legal team discovered Claude Code's potential through experimentation, and a desire to learn about Anthropic's product offerings. Additionally, one team member had a personal use case related to creating accessibility tools for family and work prototypes that demonstrate the technology's power for non-developers. The Legal team discovered Claude Code's potential through experimentation, and a desire to learn about Anthropic's product offerings. Additionally, one team member had a personal use case related to creating accessibility tools for fomily and work prototypes that demonstrate the technology's power for non-developers." } ] } }, { "object": "block", - "id": "a8c4b992-c10c-4fc6-8471-6c6f26eabb95", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537289Z", + "id": "bk_01jxwgvyqfezx8x33wv5jbksnc", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.417104Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Column 1: Web Development" }, + "text": { + "content": "Main Claude Code use cases " + }, "annotations": {}, - "plain_text": "Column 1: Web Development" + "plain_text": "Main Claude Code use cases " + }, + { + "type": "text", + "text": { + "content": "Main Claude Code use cases" + }, + "annotations": { + "bold": true + }, + "plain_text": "Main Claude Code use cases" } ] } }, { "object": "block", - "id": "fcd1a94c-7a7f-49de-9e2a-443f2eb8f247", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537331Z", + "id": "bk_01jxwgvyqgfjtsnna52eyvsdb6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.417340Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "Web development is the work involved in developing a website for the Internet or an intranet. Web development can range from developing a simple single static page of plain text to complex web applications, electronic businesses, and social network services." + "content": "Custom accessibility solution for family members " }, "annotations": {}, - "plain_text": "Web development is the work involved in developing a website for the Internet or an intranet. Web development can range from developing a simple single static page of plain text to complex web applications, electronic businesses, and social network services." + "plain_text": "Custom accessibility solution for family members " + }, + { + "type": "text", + "text": { + "content": "Custom accessibility solution for family members" + }, + "annotations": { + "bold": true + }, + "plain_text": "Custom accessibility solution for family members" } ] } }, { "object": "block", - "id": "a7d98ba6-6941-4ad7-bfbe-ac3bcc454a40", + "id": "bk_01jxwgvyqhe969sv8sv02s2v97", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537370Z", + "created_time": "2025-06-16T14:04:08.417509Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Column 2: UI Design" }, + "text": { + "content": "Team members have built communication assistants for family members with speaking difficulties due to medical diagnoses. In just one hour, they created a predictive text app using native speech-to-text that suggests responses and speaks them using voice banks, solving gaps in existing accessibility tools recommended by speech therapists. Team members have built communication assistants for family members with speaking difficulties due to medical diagnoses. In just one hour, they created a predictive text app using native speech-to-text that suggests responses and speaks them using voice banks, solving gaps in existing accessibility tools recommended by speech therapists." + }, "annotations": {}, - "plain_text": "Column 2: UI Design" + "plain_text": "Team members have built communication assistants for family members with speaking difficulties due to medical diagnoses. In just one hour, they created a predictive text app using native speech-to-text that suggests responses and speaks them using voice banks, solving gaps in existing accessibility tools recommended by speech therapists. Team members have built communication assistants for family members with speaking difficulties due to medical diagnoses. In just one hour, they created a predictive text app using native speech-to-text that suggests responses and speaks them using voice banks, solving gaps in existing accessibility tools recommended by speech therapists." } ] } }, { "object": "block", - "id": "69dc2e2e-8570-4128-a04a-1c7808a754b3", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537407Z", + "id": "bk_01jxwgvyqje03vefm1jxr2kz8d", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.417728Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "User interface design is the design of user interfaces for machines and software, such as computers, home appliances, mobile devices, and other electronic devices, with the focus on maximizing usability and the user experience." + "content": "Legal department workflow automation " }, "annotations": {}, - "plain_text": "User interface design is the design of user interfaces for machines and software, such as computers, home appliances, mobile devices, and other electronic devices, with the focus on maximizing usability and the user experience." + "plain_text": "Legal department workflow automation " + }, + { + "type": "text", + "text": { + "content": "Legal department workflow automation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Legal department workflow automation" } ] } }, { "object": "block", - "id": "bc333d8d-c3d4-4a65-acbb-052ca88a7a59", + "id": "bk_01jxwgvyqkf218w4fxawa7vec4", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537446Z", + "created_time": "2025-06-16T14:04:08.417880Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Column 3: UX Research" }, + "text": { + "content": "They created prototype \"phone tree\" systems to help team members connect with the right lawyer at Anthropic, demonstrating how legal departments can build custom tools for common tasks without traditional development resources. They created prototype \"phone tree\" systems to help team members connect with the right lawyer at Anthropic, demonstrating how legal departments can build custom tools for common tasks without traditional development resources." + }, "annotations": {}, - "plain_text": "Column 3: UX Research" + "plain_text": "They created prototype \"phone tree\" systems to help team members connect with the right lawyer at Anthropic, demonstrating how legal departments can build custom tools for common tasks without traditional development resources. They created prototype \"phone tree\" systems to help team members connect with the right lawyer at Anthropic, demonstrating how legal departments can build custom tools for common tasks without traditional development resources." } ] } }, { "object": "block", - "id": "bce09f19-f768-4b7a-bdc8-fb343637923d", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537485Z", + "id": "bk_01jxwgvyqmev1bvmf0mrkzq27w", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.418106Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "User experience research is the systematic investigation of users and their requirements, in order to add context and insight into the process of designing the user experience. UX researchers adopt various methods to uncover problems and design opportunities." + "content": "Team coordination tools " }, "annotations": {}, - "plain_text": "User experience research is the systematic investigation of users and their requirements, in order to add context and insight into the process of designing the user experience. UX researchers adopt various methods to uncover problems and design opportunities." + "plain_text": "Team coordination tools " + }, + { + "type": "text", + "text": { + "content": "Team coordination tools" + }, + "annotations": { + "bold": true + }, + "plain_text": "Team coordination tools" } ] } }, { "object": "block", - "id": "d563eea1-2542-477e-bf85-895740fcf195", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.537530Z", + "id": "bk_01jxwgvyqnfnq823gynjpbe449", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.418261Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "CSS Multi-Column Layout" }, + "text": { + "content": "Managers have built G Suite applications that automate weekly team updates and track legal review status across products, allowing lawyers to quickly flag items needing review through simple button clicks rather than spreadsheet management. Managers have built G Suite applications that automate weekly team updates and track legal review status across products, allowing lawyers to quickly flag items needing review through simple button clicks rather than spreadsheet management." + }, "annotations": {}, - "plain_text": "CSS Multi-Column Layout" + "plain_text": "Managers have built G Suite applications that automate weekly team updates and track legal review status across products, allowing lawyers to quickly flag items needing review through simple button clicks rather than spreadsheet management. Managers have built G Suite applications that automate weekly team updates and track legal review status across products, allowing lawyers to quickly flag items needing review through simple button clicks rather than spreadsheet management." } ] } }, { "object": "block", - "id": "fc37d007-f347-48a0-8cc5-72840465341e", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537562Z", + "id": "bk_01jxwgvyqpe3qtbhgdepms3467", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.418479Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "The Evolution of Web Technologies" }, + "text": { + "content": "Rapid prototyping for solution validation " + }, "annotations": {}, - "plain_text": "The Evolution of Web Technologies" + "plain_text": "Rapid prototyping for solution validation " + }, + { + "type": "text", + "text": { + "content": "Rapid prototyping for solution validation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Rapid prototyping for solution validation" } ] } }, { "object": "block", - "id": "34c9877f-817e-4b1b-8b32-fdcc7ac8c61c", + "id": "bk_01jxwgvyqqfpxrj8gwdw58xe0a", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537597Z", + "created_time": "2025-06-16T14:04:08.418630Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 21 + } + }, "paragraph": { "rich_text": [ { "type": "text", "text": { - "content": "The World Wide Web has evolved significantly since its inception in the early 1990s. What began as a simple system for sharing text documents has transformed into a complex ecosystem supporting rich media, real-time communication, and sophisticated applications." + "content": "They use Claude Code to quickly build functional prototypes they can show to domain experts (like showing accessibility tools to UCSF specialists) to validate ideas and identify existing solutions before investing more time. They use Claude Code to quickly build functional prototypes they can show to domain experts (like showing accessibility tools to UCSF specialists) to validate ideas and identify existing solutions before investing more time." }, "annotations": {}, - "plain_text": "The World Wide Web has evolved significantly since its inception in the early 1990s. What began as a simple system for sharing text documents has transformed into a complex ecosystem supporting rich media, real-time communication, and sophisticated applications." + "plain_text": "They use Claude Code to quickly build functional prototypes they can show to domain experts (like showing accessibility tools to UCSF specialists) to validate ideas and identify existing solutions before investing more time. They use Claude Code to quickly build functional prototypes they can show to domain experts (like showing accessibility tools to UCSF specialists) to validate ideas and identify existing solutions before investing more time." } ] } }, { "object": "block", - "id": "b5797b1b-997a-4431-a9f8-072c23820d62", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537632Z", + "id": "bk_01jxwgvyqsepfvgjxnetmyyf3s", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.424322Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "HTML5 introduced native support for video and audio elements, eliminating the need for plugins like Flash. CSS3 brought responsive design capabilities, allowing websites to adapt to different screen sizes. JavaScript frameworks like React, Angular, and Vue have revolutionized front-end development." + "content": "Claude Code for legal " }, "annotations": {}, - "plain_text": "HTML5 introduced native support for video and audio elements, eliminating the need for plugins like Flash. CSS3 brought responsive design capabilities, allowing websites to adapt to different screen sizes. JavaScript frameworks like React, Angular, and Vue have revolutionized front-end development." + "plain_text": "Claude Code for legal " + }, + { + "type": "text", + "text": { + "content": "Claude Code for legal" + }, + "annotations": { + "bold": true + }, + "plain_text": "Claude Code for legal" } ] } }, { "object": "block", - "id": "11f34bde-bb44-4bf7-be1d-bdcd01aadcea", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537664Z", + "id": "bk_01jxwgvyqtfv1sq296836x53nh", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.424558Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "WebAssembly is enabling high-performance applications to run in browsers. Progressive Web Apps combine the best of web and mobile apps. Meanwhile, technologies like WebRTC facilitate peer-to-peer communication directly in browsers without plugins." + "content": "Work style and impact" }, - "annotations": {}, - "plain_text": "WebAssembly is enabling high-performance applications to run in browsers. Progressive Web Apps combine the best of web and mobile apps. Meanwhile, technologies like WebRTC facilitate peer-to-peer communication directly in browsers without plugins." + "annotations": { + "bold": true + }, + "plain_text": "Work style and impact" } ] } }, { "object": "block", - "id": "21162fcc-0c30-4d9c-be6e-6d324397d516", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537699Z", + "id": "bk_01jxwgvyqvfpsbcx6a795yh93p", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.424772Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "The adoption of HTTP/2 and HTTP/3 has improved performance through multiplexing and reduced latency. Content delivery networks distribute resources globally for faster access. Serverless architectures abstract infrastructure management, allowing developers to focus on code." + "content": "Work style and impact Planning in Claude.ai, building in Claude Code " }, "annotations": {}, - "plain_text": "The adoption of HTTP/2 and HTTP/3 has improved performance through multiplexing and reduced latency. Content delivery networks distribute resources globally for faster access. Serverless architectures abstract infrastructure management, allowing developers to focus on code." + "plain_text": "Work style and impact Planning in Claude.ai, building in Claude Code " + }, + { + "type": "text", + "text": { + "content": "Planning in Claude.ai, building in Claude Code" + }, + "annotations": { + "bold": true + }, + "plain_text": "Planning in Claude.ai, building in Claude Code" } ] } }, { "object": "block", - "id": "d0dbb79c-0bd9-42b8-b481-a364d6c7af51", + "id": "bk_01jxwgvyqwf0hssdkdeprbq6gy", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.537732Z", + "created_time": "2025-06-16T14:04:08.424922Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", "text": { - "content": "As web technologies continue to evolve, we're seeing increased emphasis on accessibility, privacy, and security. The future web promises even greater capabilities with technologies like augmented reality, machine learning integration, and improved offline functionality." + "content": "They use a two-step process where they brainstorm and plan with Claude.ai first, then move to Claude Code for implementation, asking it to slow down and work step-by-step rather than outputting everything at once. They use a two-step process where they brainstorm and plan with Claude.ai first, then move to Claude Code for implementation, asking it to slow down and work step-by-step rather than outputting everything at once." }, "annotations": {}, - "plain_text": "As web technologies continue to evolve, we're seeing increased emphasis on accessibility, privacy, and security. The future web promises even greater capabilities with technologies like augmented reality, machine learning integration, and improved offline functionality." + "plain_text": "They use a two-step process where they brainstorm and plan with Claude.ai first, then move to Claude Code for implementation, asking it to slow down and work step-by-step rather than outputting everything at once. They use a two-step process where they brainstorm and plan with Claude.ai first, then move to Claude Code for implementation, asking it to slow down and work step-by-step rather than outputting everything at once." } ] } }, { "object": "block", - "id": "76f55743-7850-4cb6-bc59-92c9b6fc1714", - "type": "divider", - "created_time": "2025-06-02T15:20:59.537759Z", - "has_children": false, - "divider": {} - }, - { - "object": "block", - "id": "2a700c5f-9438-44c6-99b6-c58d2bf14903", + "id": "bk_01jxwgvyqxf2x97yz5k20yt1w6", "type": "heading_2", - "created_time": "2025-06-02T15:20:59.537789Z", + "created_time": "2025-06-16T14:04:08.425147Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "heading_2": { "rich_text": [ { "type": "text", - "text": { "content": "Code Blocks" }, + "text": { + "content": "Visual-first approach " + }, "annotations": {}, - "plain_text": "Code Blocks" + "plain_text": "Visual-first approach " + }, + { + "type": "text", + "text": { + "content": "Visual-first approach" + }, + "annotations": { + "bold": true + }, + "plain_text": "Visual-first approach" } ] } }, { "object": "block", - "id": "7df299b0-7b88-4021-849a-a7e246175d69", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.537815Z", + "id": "bk_01jxwgvyqyew1sa9egsxaybsyz", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.425293Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "JavaScript" }, + "text": { + "content": "They frequently use screenshots to show Claude Code what they want interfaces to look like, then iterate based on visual feedback rather than describing features in text. They frequently use screenshots to show Claude Code what they want interfaces to look like, then iterate based on visual feedback rather than describing features in text." + }, "annotations": {}, - "plain_text": "JavaScript" + "plain_text": "They frequently use screenshots to show Claude Code what they want interfaces to look like, then iterate based on visual feedback rather than describing features in text. They frequently use screenshots to show Claude Code what they want interfaces to look like, then iterate based on visual feedback rather than describing features in text." } ] } }, { "object": "block", - "id": "c2277727-dd9b-4a06-9afc-aaac164903d5", - "type": "code", - "created_time": "2025-06-02T15:20:59.537861Z", + "id": "bk_01jxwgvyqzevhret08md18wcz3", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.425503Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "code": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "function greet(name) {\n console.log(\"Hello, \" + name);\n}\ngreet(\"World\");" + "content": "Prototype-driven innovation " }, "annotations": {}, - "plain_text": "function greet(name) {\n console.log(\"Hello, \" + name);\n}\ngreet(\"World\");" + "plain_text": "Prototype-driven innovation " + }, + { + "type": "text", + "text": { + "content": "Prototype-driven innovation" + }, + "annotations": { + "bold": true + }, + "plain_text": "Prototype-driven innovation" } ] } }, { "object": "block", - "id": "911dd110-c587-4736-ab77-0f7caf8e973a", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.538054Z", + "id": "bk_01jxwgvyr0e4r8ps425e6fvq2d", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.425639Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "Python" }, + "text": { + "content": "They emphasize overcoming the fear of sharing \"silly\" or \"toy\" prototypes, as these demonstrations inspire others to see possibilities they hadn't considered. They emphasize overcoming the fear of sharing \"silly\" or \"toy\" prototypes, as these demonstrations inspire others to see possibilities they hadn't considered." + }, "annotations": {}, - "plain_text": "Python" + "plain_text": "They emphasize overcoming the fear of sharing \"silly\" or \"toy\" prototypes, as these demonstrations inspire others to see possibilities they hadn't considered. They emphasize overcoming the fear of sharing \"silly\" or \"toy\" prototypes, as these demonstrations inspire others to see possibilities they hadn't considered." } ] } }, { "object": "block", - "id": "d09e9be1-499c-4eb9-acdf-6beee0ff3c06", - "type": "code", - "created_time": "2025-06-02T15:20:59.538101Z", + "id": "bk_01jxwgvyr1ebxbs4fp8xp9y8gv", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.425851Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "code": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", "text": { - "content": "def greet(name):\n print(f\"Hello, {name}\")\n\ngreet(\"World\")" + "content": "Security and compliance awareness " }, "annotations": {}, - "plain_text": "def greet(name):\n print(f\"Hello, {name}\")\n\ngreet(\"World\")" + "plain_text": "Security and compliance awareness " + }, + { + "type": "text", + "text": { + "content": "Security and compliance awareness" + }, + "annotations": { + "bold": true + }, + "plain_text": "Security and compliance awareness" } ] } }, { "object": "block", - "id": "470ebc95-cd81-4941-a5f1-f096dd593e8e", - "type": "heading_3", - "created_time": "2025-06-02T15:20:59.538151Z", + "id": "bk_01jxwgvyr2e708k8hkxbzx4qe6", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.426072Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_3": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "HTML" }, + "text": { + "content": "MCP integration concerns " + }, "annotations": {}, - "plain_text": "HTML" + "plain_text": "MCP integration concerns " + }, + { + "type": "text", + "text": { + "content": "MCP integration concerns" + }, + "annotations": { + "bold": true + }, + "plain_text": "MCP integration concerns" } ] } }, { "object": "block", - "id": "ed5ccbb5-3caf-4ac1-8f09-9f6483930a12", - "type": "code", - "created_time": "2025-06-02T15:20:59.538195Z", + "id": "bk_01jxwgvyr3fpfaseex82vf3smz", + "type": "paragraph", + "created_time": "2025-06-16T14:04:08.426213Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "code": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "paragraph": { "rich_text": [ { "type": "text", "text": { - "content": "
\n

Hello World

\n
" + "content": "As product lawyers, they immediately identify security implications of deep MCP integrations, noting how conservative security postures will create barriers as AI tools access more sensitive systems. As product lawyers, they immediately identify security implications of deep MCP integrations, noting how conservative security postures will create barriers as AI tools access more sensitive systems." }, "annotations": {}, - "plain_text": "
\n

Hello World

\n
" + "plain_text": "As product lawyers, they immediately identify security implications of deep MCP integrations, noting how conservative security postures will create barriers as AI tools access more sensitive systems. As product lawyers, they immediately identify security implications of deep MCP integrations, noting how conservative security postures will create barriers as AI tools access more sensitive systems." } ] } }, { "object": "block", - "id": "7b630b74-7445-4907-8983-befce6f73707", - "type": "divider", - "created_time": "2025-06-02T15:20:59.538230Z", - "has_children": false, - "divider": {} - }, - { - "object": "block", - "id": "d48296b2-6b2e-4bb9-ad65-ca5069ef5d08", - "type": "heading_2", - "created_time": "2025-06-02T15:20:59.538269Z", + "id": "bk_01jxwgvyr4e2nbjbefvd1gx60w", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.426424Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "heading_2": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": "Form Elements" }, + "text": { + "content": "Compliance tooling priorities " + }, "annotations": {}, - "plain_text": "Form Elements" + "plain_text": "Compliance tooling priorities " + }, + { + "type": "text", + "text": { + "content": "Compliance tooling priorities" + }, + "annotations": { + "bold": true + }, + "plain_text": "Compliance tooling priorities" } ] } }, { "object": "block", - "id": "0e3c3c0a-5d95-46db-93f3-beb9778dc042", + "id": "bk_01jxwgvyr5er8baqe2nmxmsmnp", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538737Z", + "created_time": "2025-06-16T14:04:08.426552Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": " Name:" }, + "text": { + "content": "They advocate for building compliance tools quickly as AI capabilities expand, recognizing the balance between innovation and risk management. They advocate for building compliance tools quickly as AI capabilities expand, recognizing the balance between innovation and risk management." + }, "annotations": {}, - "plain_text": " Name:" + "plain_text": "They advocate for building compliance tools quickly as AI capabilities expand, recognizing the balance between innovation and risk management. They advocate for building compliance tools quickly as AI capabilities expand, recognizing the balance between innovation and risk management." } ] } }, { "object": "block", - "id": "460f0648-91f8-4c59-9613-2333641afacd", + "id": "bk_01jxwgvyr6ea1vz5kx6hedrrze", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538766Z", + "created_time": "2025-06-16T14:04:08.426762Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": " Email:" }, + "text": { + "content": "Top tips from the Legal Department " + }, "annotations": {}, - "plain_text": " Email:" + "plain_text": "Top tips from the Legal Department " + }, + { + "type": "text", + "text": { + "content": "Top tips from the Legal Department" + }, + "annotations": { + "bold": true + }, + "plain_text": "Top tips from the Legal Department" } ] } }, { "object": "block", - "id": "af41dace-7627-4788-a823-9944b73f874d", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538783Z", + "id": "bk_01jxwgvyr7ec1bxwy78gm8f3bj", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.426971Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_2": { "rich_text": [ { "type": "text", - "text": { "content": " Gender: Male Female" }, + "text": { + "content": "Plan extensively in Claude.ai first " + }, "annotations": {}, - "plain_text": " Gender: Male Female" + "plain_text": "Plan extensively in Claude.ai first " + }, + { + "type": "text", + "text": { + "content": "Plan extensively in Claude.ai first" + }, + "annotations": { + "bold": true + }, + "plain_text": "Plan extensively in Claude.ai first" } ] } }, { "object": "block", - "id": "4a7a54a9-942a-4b00-91a8-74416872395e", + "id": "bk_01jxwgvyr8fwasyxvv0tdg96v6", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538798Z", + "created_time": "2025-06-16T14:04:08.427144Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": " Interests: Coding Design" }, + "text": { + "content": "Use Claude's conversational interface to flesh out your entire idea before moving to Claude Code. Then ask Claude to summarize everything into a step-by-step prompt for implementation. Use Claude's conversational interface to flesh out your entire idea before moving to Claude Code. Then ask Claude to summarize everything into a step-by-step prompt for implementation." + }, "annotations": {}, - "plain_text": " Interests: Coding Design" + "plain_text": "Use Claude's conversational interface to flesh out your entire idea before moving to Claude Code. Then ask Claude to summarize everything into a step-by-step prompt for implementation. Use Claude's conversational interface to flesh out your entire idea before moving to Claude Code. Then ask Claude to summarize everything into a step-by-step prompt for implementation." } ] } }, { "object": "block", - "id": "8809fca5-b7fd-40c8-9340-b4eaa9a483d2", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538812Z", + "id": "bk_01jxwgvyr9fn1bacm70xjgeg0w", + "type": "heading_2", + "created_time": "2025-06-16T14:04:08.427369Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_2": { "rich_text": [ { "type": "text", - "text": { "content": " Bio:" }, + "text": { + "content": "Work incrementally and visually " + }, "annotations": {}, - "plain_text": " Bio:" + "plain_text": "Work incrementally and visually " + }, + { + "type": "text", + "text": { + "content": "Work incrementally and visually" + }, + "annotations": { + "bold": true + }, + "plain_text": "Work incrementally and visually" } ] } }, { "object": "block", - "id": "c1c55595-e3f5-4426-800e-aaa13a45b354", + "id": "bk_01jxwgvyraf16vgpk2s8czdf18", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538829Z", + "created_time": "2025-06-16T14:04:08.427514Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": " Language: JavaScript Python TypeScript" }, + "text": { + "content": "Ask Claude Code to slow down and implement one step at a time so you can copy-paste without getting overwhelmed. Use screenshots liberally to show what you want interfaces to look like. Ask Claude Code to slow down and implement one step at a time so you can copy-paste without getting overwhelmed. Use screenshots liberally to show what you want interfaces to look like." + }, "annotations": {}, - "plain_text": " Language: JavaScript Python TypeScript" + "plain_text": "Ask Claude Code to slow down and implement one step at a time so you can copy-paste without getting overwhelmed. Use screenshots liberally to show what you want interfaces to look like. Ask Claude Code to slow down and implement one step at a time so you can copy-paste without getting overwhelmed. Use screenshots liberally to show what you want interfaces to look like." } ] } }, { "object": "block", - "id": "74627872-6805-45ac-9f5b-bf9cb6229750", - "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538845Z", + "id": "bk_01jxwgvyrbekmtrrkmh5qm50zy", + "type": "heading_1", + "created_time": "2025-06-16T14:04:08.427725Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, - "paragraph": { + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, + "heading_1": { "rich_text": [ { "type": "text", - "text": { "content": " Submit" }, + "text": { + "content": "Share prototypes despite imperfection " + }, "annotations": {}, - "plain_text": " Submit" + "plain_text": "Share prototypes despite imperfection " + }, + { + "type": "text", + "text": { + "content": "Share prototypes despite hnperfection" + }, + "annotations": { + "bold": true + }, + "plain_text": "Share prototypes despite hnperfection" } ] } }, { "object": "block", - "id": "c3b8af60-ba61-4c37-b0ff-f3026aa74def", + "id": "bk_01jxwgvyrceensx2gvnbr6wr3b", "type": "paragraph", - "created_time": "2025-06-02T15:20:59.538478Z", + "created_time": "2025-06-16T14:04:08.427863Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, "has_children": false, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 22 + } + }, "paragraph": { "rich_text": [ { "type": "text", - "text": { "content": "\u00a9 2025 HTML QA Page" }, + "text": { + "content": "Overcome the urge to hide \"toy\" projects or unfinished work - sharing prototypes helps others see possibilities and sparks innovation across departments that don't typically interact. Overcome the urge to hide \"toy\" projects or unfinished work -sharing prototypes helps others see possibilities and sparks innovation across departments that don't typically interact." + }, "annotations": {}, - "plain_text": "\u00a9 2025 HTML QA Page" + "plain_text": "Overcome the urge to hide \"toy\" projects or unfinished work - sharing prototypes helps others see possibilities and sparks innovation across departments that don't typically interact. Overcome the urge to hide \"toy\" projects or unfinished work -sharing prototypes helps others see possibilities and sparks innovation across departments that don't typically interact." } ] } + }, + { + "object": "block", + "id": "bk_01jxwgvyrefat9h22v77fx7gkm", + "type": "image", + "created_time": "2025-06-16T14:04:08.432028Z", + "created_by": { + "object": "user", + "id": "28a08aa3-192b-45e6-b6d3-32b8032d8c7b" + }, + "metadata": { + "origin": { + "file_id": "file_01jxwgtg7qfr79j59j7xe777ek", + "page_num": 23 + } + }, + "image": { + "type": "external", + "external": { + "url": "textcortex://images/img_0z4nyaw5pj9bwr3k81th5gx4cv" + }, + "caption": [] + } } ] } diff --git a/typescript/examples/vite_basic/src/App.tsx b/typescript/examples/vite_basic/src/App.tsx index 001bf12..f1a0467 100644 --- a/typescript/examples/vite_basic/src/App.tsx +++ b/typescript/examples/vite_basic/src/App.tsx @@ -1,4 +1,4 @@ -import { JsonDocRenderer } from "@textcortex/jsondoc"; +import { JsonDocRenderer, PageDelimiter } from "@textcortex/jsondoc"; import "@textcortex/jsondoc/dist/index.css"; import { useState, useEffect } from "react"; @@ -37,7 +37,16 @@ const App = () => { >

JSON-DOC Renderer Development

- + { + return ; + }, + }} + />
); diff --git a/typescript/src/index.ts b/typescript/src/index.ts index 401ab60..3d13119 100644 --- a/typescript/src/index.ts +++ b/typescript/src/index.ts @@ -11,6 +11,21 @@ export { } from "./utils/json"; // Export React renderer components -export { JsonDocRenderer, BlockRenderer } from "./renderer"; +export { + JsonDocRenderer, + PageDelimiter, + ParagraphBlockRenderer, + HeadingBlockRenderer, + ListItemBlockRenderer, + CodeBlockRenderer, + ImageBlockRenderer, + TableBlockRenderer, + QuoteBlockRenderer, + DividerBlockRenderer, + ToDoBlockRenderer, + ToggleBlockRenderer, + ColumnListBlockRenderer, + EquationBlockRenderer, +} from "./renderer"; export type { JsonDocRendererProps, BlockRendererProps } from "./renderer"; diff --git a/typescript/src/renderer/JsonDocRenderer.tsx b/typescript/src/renderer/JsonDocRenderer.tsx index c35a7db..ec72903 100644 --- a/typescript/src/renderer/JsonDocRenderer.tsx +++ b/typescript/src/renderer/JsonDocRenderer.tsx @@ -12,7 +12,11 @@ import { RendererProvider } from "./context/RendererContext"; interface JsonDocRendererProps { page: Page; className?: string; - components?: React.ComponentProps["components"]; + components?: React.ComponentProps["components"] & { + page_delimiter: React.ComponentType<{ + pageNumber: number; + }>; + }; theme?: "light" | "dark"; resolveImageUrl?: (url: string) => Promise; devMode?: boolean; @@ -27,6 +31,7 @@ export const JsonDocRenderer = ({ resolveImageUrl, devMode = false, viewJson = false, + // PageDelimiterComponent = PageDelimiter, }: JsonDocRendererProps) => { console.log("page: ", page); @@ -47,7 +52,6 @@ export const JsonDocRenderer = ({ // return null; const renderedContent = (
- hello {/* Page icon */} {page.icon && (
@@ -83,9 +87,13 @@ export const JsonDocRenderer = ({ depth={0} components={components} /> - {showPageDelimiter && ( + + {showPageDelimiter && !components?.page_delimiter && ( )} + {showPageDelimiter && components?.page_delimiter && ( + + )} ); })} @@ -96,7 +104,6 @@ export const JsonDocRenderer = ({ return ( - hello and hello
{viewJson ? (
diff --git a/typescript/src/renderer/components/BlockRenderer.tsx b/typescript/src/renderer/components/BlockRenderer.tsx index bc3b130..5e707fb 100644 --- a/typescript/src/renderer/components/BlockRenderer.tsx +++ b/typescript/src/renderer/components/BlockRenderer.tsx @@ -2,7 +2,6 @@ import React from "react"; import { Block, - BlockBase, Heading1Block, Heading2Block, Heading3Block, diff --git a/typescript/src/renderer/index.ts b/typescript/src/renderer/index.ts index e849c5e..b41cb67 100644 --- a/typescript/src/renderer/index.ts +++ b/typescript/src/renderer/index.ts @@ -9,6 +9,7 @@ export { CodeBlockRenderer } from "./components/blocks/CodeBlockRenderer"; export { ImageBlockRenderer } from "./components/blocks/ImageBlockRenderer"; export { TableBlockRenderer } from "./components/blocks/TableBlockRenderer"; export { JsonDocRenderer } from "./JsonDocRenderer"; +export { PageDelimiter } from "./components/PageDelimiter"; export { QuoteBlockRenderer } from "./components/blocks/QuoteBlockRenderer"; export { DividerBlockRenderer } from "./components/blocks/DividerBlockRenderer"; export { ToDoBlockRenderer } from "./components/blocks/ToDoBlockRenderer"; @@ -16,9 +17,6 @@ export { ToggleBlockRenderer } from "./components/blocks/ToggleBlockRenderer"; export { ColumnListBlockRenderer } from "./components/blocks/ColumnListBlockRenderer"; export { EquationBlockRenderer } from "./components/blocks/EquationBlockRenderer"; -// Export context -export { RendererProvider, useRenderer } from "./context"; - // Export types export type { BlockComponents } from "./components/BlockRenderer"; export type { JsonDocRendererProps, BlockRendererProps } from "./types"; From 19c1784dc480c595f52333a7515e8568113e75cd Mon Sep 17 00:00:00 2001 From: Abreham Gezahegn Date: Mon, 16 Jun 2025 22:50:19 +0300 Subject: [PATCH 2/3] checkpoint --- typescript/examples/vite_basic/src/App.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/typescript/examples/vite_basic/src/App.tsx b/typescript/examples/vite_basic/src/App.tsx index f1a0467..44be15e 100644 --- a/typescript/examples/vite_basic/src/App.tsx +++ b/typescript/examples/vite_basic/src/App.tsx @@ -43,7 +43,7 @@ const App = () => { devMode={true} components={{ page_delimiter: (props) => { - return ; + return ; }, }} /> From 8a541c694cc77ea590ada3604aab37a237d3a82d Mon Sep 17 00:00:00 2001 From: Abreham Gezahegn Date: Tue, 17 Jun 2025 10:05:21 +0300 Subject: [PATCH 3/3] move some deps to dev deps --- typescript/package-lock.json | 111 ++++++++++++++++++++++++++++++++--- typescript/package.json | 10 ++-- 2 files changed, 108 insertions(+), 13 deletions(-) diff --git a/typescript/package-lock.json b/typescript/package-lock.json index 79cda98..3d0743a 100644 --- a/typescript/package-lock.json +++ b/typescript/package-lock.json @@ -11,11 +11,8 @@ "dependencies": { "ajv": "^8.17.1", "ajv-formats": "^3.0.1", - "json5": "^2.2.3", "katex": "^0.16.22", - "puppeteer": "^24.9.0", - "react-intersection-observer": "^9.13.0", - "strip-json-comments": "^5.0.2" + "react-intersection-observer": "^9.13.0" }, "devDependencies": { "@eslint/js": "^9.28.0", @@ -39,8 +36,11 @@ "identity-obj-proxy": "^3.0.0", "jest": "^29.7.0", "json-schema-to-typescript": "^15.0.4", + "json5": "^2.2.3", "lint-staged": "^15.5.2", "prettier": "3.5.3", + "puppeteer": "^24.9.0", + "strip-json-comments": "^5.0.2", "ts-jest": "^29.3.4", "ts-node": "^10.9.2", "tsup": "^8.5.0", @@ -110,6 +110,7 @@ "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", @@ -251,6 +252,7 @@ "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "dev": true, "license": "MIT", "engines": { "node": ">=6.9.0" @@ -1834,6 +1836,7 @@ "version": "2.10.5", "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.5.tgz", "integrity": "sha512-eifa0o+i8dERnngJwKrfp3dEq7ia5XFyoqB17S4gK8GhsQE4/P8nxOfQSE0zQHxzzLo/cmF+7+ywEQ7wK7Fb+w==", + "dev": true, "license": "Apache-2.0", "dependencies": { "debug": "^4.4.1", @@ -1855,6 +1858,7 @@ "version": "7.7.2", "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, "license": "ISC", "bin": { "semver": "bin/semver.js" @@ -2160,6 +2164,7 @@ "version": "0.23.0", "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz", "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==", + "dev": true, "license": "MIT" }, "node_modules/@tsconfig/node10": { @@ -2322,7 +2327,7 @@ "version": "22.15.27", "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.27.tgz", "integrity": "sha512-5fF+eu5mwihV2BeVtX5vijhdaZOfkQTATrePEaXTcKqI16LhJ7gi2/Vhd9OZM0UojcdmiOCVg5rrax+i1MdoQQ==", - "devOptional": true, + "dev": true, "dependencies": { "undici-types": "~6.21.0" } @@ -2375,6 +2380,7 @@ "version": "2.10.3", "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz", "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==", + "dev": true, "license": "MIT", "optional": true, "dependencies": { @@ -2903,6 +2909,7 @@ "version": "7.1.3", "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz", "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==", + "dev": true, "license": "MIT", "engines": { "node": ">= 14" @@ -2963,6 +2970,7 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -2972,6 +2980,7 @@ "version": "4.3.0", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, "license": "MIT", "dependencies": { "color-convert": "^2.0.1" @@ -3200,6 +3209,7 @@ "version": "0.13.4", "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz", "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==", + "dev": true, "license": "MIT", "dependencies": { "tslib": "^2.0.1" @@ -3267,6 +3277,7 @@ "version": "1.6.7", "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz", "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==", + "dev": true, "license": "Apache-2.0" }, "node_modules/babel-jest": { @@ -3396,6 +3407,7 @@ "version": "2.5.4", "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.5.4.tgz", "integrity": "sha512-+gFfDkR8pj4/TrWCGUGWmJIkBwuxPS5F+a5yWjOHQt2hHvNZd5YLzadjmDUtFmMM4y429bnKLa8bYBMHcYdnQA==", + "dev": true, "license": "Apache-2.0", "optional": true }, @@ -3403,6 +3415,7 @@ "version": "4.1.5", "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.1.5.tgz", "integrity": "sha512-1zccWBMypln0jEE05LzZt+V/8y8AQsQQqxtklqaIyg5nu6OAYFhZxPXinJTSG+kU5qyNmeLgcn9AW7eHiCHVLA==", + "dev": true, "license": "Apache-2.0", "optional": true, "dependencies": { @@ -3426,6 +3439,7 @@ "version": "3.6.1", "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz", "integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==", + "dev": true, "license": "Apache-2.0", "optional": true, "engines": { @@ -3436,6 +3450,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz", "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==", + "dev": true, "license": "Apache-2.0", "optional": true, "dependencies": { @@ -3446,6 +3461,7 @@ "version": "2.6.5", "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.5.tgz", "integrity": "sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==", + "dev": true, "license": "Apache-2.0", "optional": true, "dependencies": { @@ -3468,6 +3484,7 @@ "version": "5.0.5", "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz", "integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==", + "dev": true, "license": "MIT", "engines": { "node": ">=10.0.0" @@ -3557,6 +3574,7 @@ "version": "0.2.13", "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", + "dev": true, "license": "MIT", "engines": { "node": "*" @@ -3732,6 +3750,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, "license": "MIT", "engines": { "node": ">=6" @@ -3814,6 +3833,7 @@ "version": "5.1.0", "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-5.1.0.tgz", "integrity": "sha512-9MSRhWRVoRPDG0TgzkHrshFSJJNZzfY5UFqUMuksg7zL1yoZIZ3jLB0YAgHclbiAxPI86pBnwDX1tbzoiV8aFw==", + "dev": true, "license": "Apache-2.0", "dependencies": { "mitt": "^3.0.1", @@ -3946,6 +3966,7 @@ "version": "8.0.1", "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, "license": "ISC", "dependencies": { "string-width": "^4.2.0", @@ -3978,6 +3999,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, "license": "MIT", "dependencies": { "color-name": "~1.1.4" @@ -3990,6 +4012,7 @@ "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, "license": "MIT" }, "node_modules/colorette": { @@ -4081,6 +4104,7 @@ "version": "9.0.0", "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz", "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==", + "dev": true, "license": "MIT", "dependencies": { "env-paths": "^2.2.1", @@ -4107,12 +4131,14 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, "license": "Python-2.0" }, "node_modules/cosmiconfig/node_modules/js-yaml": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, "license": "MIT", "dependencies": { "argparse": "^2.0.1" @@ -4182,6 +4208,7 @@ "version": "6.0.2", "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz", "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==", + "dev": true, "license": "MIT", "engines": { "node": ">= 14" @@ -4242,6 +4269,7 @@ "version": "4.4.1", "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "dev": true, "license": "MIT", "dependencies": { "ms": "^2.1.3" @@ -4330,6 +4358,7 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz", "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==", + "dev": true, "license": "MIT", "dependencies": { "ast-types": "^0.13.4", @@ -4360,6 +4389,7 @@ "version": "0.0.1439962", "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1439962.tgz", "integrity": "sha512-jJF48UdryzKiWhJ1bLKr7BFWUQCEIT5uCNbDLqkQJBtkFxYzILJH44WN0PDKMIlGDN7Utb8vyUY85C3w4R/t2g==", + "dev": true, "license": "BSD-3-Clause" }, "node_modules/diff": { @@ -4466,12 +4496,14 @@ "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, "license": "MIT" }, "node_modules/end-of-stream": { "version": "1.4.4", "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", + "dev": true, "license": "MIT", "dependencies": { "once": "^1.4.0" @@ -4481,6 +4513,7 @@ "version": "2.2.1", "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "dev": true, "license": "MIT", "engines": { "node": ">=6" @@ -4503,6 +4536,7 @@ "version": "1.3.2", "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, "license": "MIT", "dependencies": { "is-arrayish": "^0.2.1" @@ -4721,6 +4755,7 @@ "version": "3.2.0", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, "license": "MIT", "engines": { "node": ">=6" @@ -4740,6 +4775,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz", "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==", + "dev": true, "license": "BSD-2-Clause", "dependencies": { "esprima": "^4.0.1", @@ -5227,6 +5263,7 @@ "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, "license": "BSD-2-Clause", "bin": { "esparse": "bin/esparse.js", @@ -5264,6 +5301,7 @@ "version": "5.3.0", "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, "license": "BSD-2-Clause", "engines": { "node": ">=4.0" @@ -5273,6 +5311,7 @@ "version": "2.0.3", "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, "license": "BSD-2-Clause", "engines": { "node": ">=0.10.0" @@ -5345,6 +5384,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz", "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==", + "dev": true, "license": "BSD-2-Clause", "dependencies": { "debug": "^4.1.1", @@ -5365,6 +5405,7 @@ "version": "5.2.0", "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, "license": "MIT", "dependencies": { "pump": "^3.0.0" @@ -5387,6 +5428,7 @@ "version": "1.3.2", "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz", "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==", + "dev": true, "license": "MIT" }, "node_modules/fast-glob": { @@ -5470,6 +5512,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", + "dev": true, "license": "MIT", "dependencies": { "pend": "~1.2.0" @@ -5695,6 +5738,7 @@ "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, "license": "ISC", "engines": { "node": "6.* || 8.* || >= 10.*" @@ -5806,6 +5850,7 @@ "version": "6.0.4", "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.4.tgz", "integrity": "sha512-E1b1lFFLvLgak2whF2xDBcOy6NLVGZBqqjJjsIhvopKfWWEi64pLVTWWehV8KlLerZkfNTA95sTe2OdJKm1OzQ==", + "dev": true, "license": "MIT", "dependencies": { "basic-ftp": "^5.0.2", @@ -6025,6 +6070,7 @@ "version": "7.0.2", "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz", "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==", + "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.0", @@ -6038,6 +6084,7 @@ "version": "7.0.6", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.2", @@ -6099,6 +6146,7 @@ "version": "3.3.1", "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, "license": "MIT", "dependencies": { "parent-module": "^1.0.0", @@ -6115,6 +6163,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, "license": "MIT", "engines": { "node": ">=4" @@ -6187,6 +6236,7 @@ "version": "9.0.5", "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz", "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==", + "dev": true, "license": "MIT", "dependencies": { "jsbn": "1.1.0", @@ -6200,6 +6250,7 @@ "version": "1.1.3", "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", + "dev": true, "license": "BSD-3-Clause" }, "node_modules/is-array-buffer": { @@ -6223,6 +6274,7 @@ "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, "license": "MIT" }, "node_modules/is-async-function": { @@ -6386,6 +6438,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, "license": "MIT", "engines": { "node": ">=8" @@ -7430,6 +7483,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz", "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==", + "dev": true, "license": "MIT" }, "node_modules/jsesc": { @@ -7455,6 +7509,7 @@ "version": "2.3.1", "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true, "license": "MIT" }, "node_modules/json-schema-to-typescript": { @@ -7518,6 +7573,7 @@ "version": "2.2.3", "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, "license": "MIT", "bin": { "json5": "lib/cli.js" @@ -7639,6 +7695,7 @@ "version": "1.2.4", "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, "license": "MIT" }, "node_modules/lint-staged": { @@ -8315,6 +8372,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz", "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==", + "dev": true, "license": "MIT" }, "node_modules/mlly": { @@ -8333,6 +8391,7 @@ "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, "license": "MIT" }, "node_modules/mz": { @@ -8392,6 +8451,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz", "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==", + "dev": true, "license": "MIT", "engines": { "node": ">= 0.4.0" @@ -8601,6 +8661,7 @@ "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, "license": "ISC", "dependencies": { "wrappy": "1" @@ -8715,6 +8776,7 @@ "version": "7.2.0", "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz", "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==", + "dev": true, "license": "MIT", "dependencies": { "@tootallnate/quickjs-emscripten": "^0.23.0", @@ -8734,6 +8796,7 @@ "version": "7.0.1", "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz", "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==", + "dev": true, "license": "MIT", "dependencies": { "degenerator": "^5.0.0", @@ -8759,6 +8822,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, "license": "MIT", "dependencies": { "callsites": "^3.0.0" @@ -8771,6 +8835,7 @@ "version": "5.2.0", "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, "license": "MIT", "dependencies": { "@babel/code-frame": "^7.0.0", @@ -8854,6 +8919,7 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", + "dev": true, "license": "MIT" }, "node_modules/perfect-debounce": { @@ -8866,6 +8932,7 @@ "version": "1.1.1", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, "license": "ISC" }, "node_modules/picomatch": { @@ -9066,6 +9133,7 @@ "version": "2.0.3", "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true, "license": "MIT", "engines": { "node": ">=0.4.0" @@ -9106,6 +9174,7 @@ "version": "6.5.0", "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz", "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==", + "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.2", @@ -9125,6 +9194,7 @@ "version": "7.18.3", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "dev": true, "license": "ISC", "engines": { "node": ">=12" @@ -9134,12 +9204,14 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "dev": true, "license": "MIT" }, "node_modules/pump": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz", "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==", + "dev": true, "license": "MIT", "dependencies": { "end-of-stream": "^1.1.0", @@ -9159,6 +9231,7 @@ "version": "24.9.0", "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-24.9.0.tgz", "integrity": "sha512-L0pOtALIx8rgDt24Y+COm8X52v78gNtBOW6EmUcEPci0TYD72SAuaXKqasRIx4JXxmg2Tkw5ySKcpPOwN8xXnQ==", + "dev": true, "hasInstallScript": true, "license": "Apache-2.0", "dependencies": { @@ -9180,6 +9253,7 @@ "version": "24.9.0", "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-24.9.0.tgz", "integrity": "sha512-HFdCeH/wx6QPz8EncafbCqJBqaCG1ENW75xg3cLFMRUoqZDgByT6HSueiumetT2uClZxwqj0qS4qMVZwLHRHHw==", + "dev": true, "license": "Apache-2.0", "dependencies": { "@puppeteer/browsers": "2.10.5", @@ -9345,6 +9419,7 @@ "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, "license": "MIT", "engines": { "node": ">=0.10.0" @@ -9852,6 +9927,7 @@ "version": "4.2.0", "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "dev": true, "license": "MIT", "engines": { "node": ">= 6.0.0", @@ -9862,6 +9938,7 @@ "version": "2.8.4", "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz", "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==", + "dev": true, "license": "MIT", "dependencies": { "ip-address": "^9.0.5", @@ -9876,6 +9953,7 @@ "version": "8.0.5", "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz", "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==", + "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.2", @@ -9890,7 +9968,7 @@ "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "devOptional": true, + "dev": true, "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" @@ -9961,6 +10039,7 @@ "version": "2.22.0", "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.0.tgz", "integrity": "sha512-sLh1evHOzBy/iWRiR6d1zRcLao4gGZr3C1kzNz4fopCOKJb6xD9ub8Mpi9Mr1R6id5o43S+d93fI48UC5uM9aw==", + "dev": true, "license": "MIT", "dependencies": { "fast-fifo": "^1.3.2", @@ -9998,6 +10077,7 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", @@ -10134,6 +10214,7 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" @@ -10179,6 +10260,7 @@ "version": "5.0.2", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-5.0.2.tgz", "integrity": "sha512-4X2FR3UwhNUE9G49aIsJW5hRRR3GXGTBTZRMfv568O60ojM8HcWjV/VxAxCDW3SUND33O6ZY66ZuRcdkj73q2g==", + "dev": true, "license": "MIT", "engines": { "node": ">=14.16" @@ -10292,6 +10374,7 @@ "version": "3.0.8", "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.0.8.tgz", "integrity": "sha512-ZoROL70jptorGAlgAYiLoBLItEKw/fUxg9BSYK/dF/GAGYFJOJJJMvjPAKDJraCXFwadD456FCuvLWgfhMsPwg==", + "dev": true, "license": "MIT", "dependencies": { "pump": "^3.0.0", @@ -10306,6 +10389,7 @@ "version": "3.1.7", "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz", "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==", + "dev": true, "license": "MIT", "dependencies": { "b4a": "^1.6.4", @@ -10332,6 +10416,7 @@ "version": "1.2.3", "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz", "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==", + "dev": true, "license": "Apache-2.0", "dependencies": { "b4a": "^1.6.4" @@ -10621,6 +10706,7 @@ "version": "2.8.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, "license": "0BSD" }, "node_modules/tsup": { @@ -10800,13 +10886,14 @@ "version": "2.12.0", "resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.0.tgz", "integrity": "sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==", + "dev": true, "license": "MIT" }, "node_modules/typescript": { "version": "5.8.3", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", - "devOptional": true, + "dev": true, "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", @@ -10844,7 +10931,7 @@ "version": "6.21.0", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", - "devOptional": true, + "dev": true, "license": "MIT" }, "node_modules/unrs-resolver": { @@ -11082,6 +11169,7 @@ "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^4.0.0", @@ -11117,6 +11205,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, "license": "ISC" }, "node_modules/write-file-atomic": { @@ -11137,6 +11226,7 @@ "version": "8.18.2", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz", "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==", + "dev": true, "license": "MIT", "engines": { "node": ">=10.0.0" @@ -11158,6 +11248,7 @@ "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, "license": "ISC", "engines": { "node": ">=10" @@ -11187,6 +11278,7 @@ "version": "17.7.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, "license": "MIT", "dependencies": { "cliui": "^8.0.1", @@ -11205,6 +11297,7 @@ "version": "21.1.1", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, "license": "ISC", "engines": { "node": ">=12" @@ -11214,6 +11307,7 @@ "version": "2.10.0", "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", + "dev": true, "license": "MIT", "dependencies": { "buffer-crc32": "~0.2.3", @@ -11247,6 +11341,7 @@ "version": "3.25.20", "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.20.tgz", "integrity": "sha512-z03fqpTMDF1G02VLKUMt6vyACE7rNWkh3gpXVHgPTw28NPtDFRGvcpTtPwn2kMKtQ0idtYJUTxchytmnqYswcw==", + "dev": true, "license": "MIT", "funding": { "url": "https://github.com/sponsors/colinhacks" diff --git a/typescript/package.json b/typescript/package.json index 55cb972..293118c 100644 --- a/typescript/package.json +++ b/typescript/package.json @@ -57,16 +57,16 @@ "ts-jest": "^29.3.4", "ts-node": "^10.9.2", "tsup": "^8.5.0", - "typescript": "^5.8.3" + "typescript": "^5.8.3", + "puppeteer": "^24.9.0", + "strip-json-comments": "^5.0.2", + "json5": "^2.2.3" }, "dependencies": { "ajv": "^8.17.1", "ajv-formats": "^3.0.1", - "json5": "^2.2.3", "katex": "^0.16.22", - "puppeteer": "^24.9.0", - "react-intersection-observer": "^9.13.0", - "strip-json-comments": "^5.0.2" + "react-intersection-observer": "^9.13.0" }, "peerDependencies": { "react": "^18.2.0",