Writing Code Documentation

How I maintain clarity in my code even with 20+ contributors: Do you find yourself staring at your own code, asking "Who wrote this terrible mess?" Even though you know it was you? You’re not alone. Poor documentation is a real headache even for a senior dev. With these 5 steps, you can avoid wasting hours trying to understand what your code means: 1. Create an Overview: Start with the project's purpose. This helps everyone stay on the same page from the beginning. 2. Detail Your Process: Break down your code step-by-step. This way, you won’t waste time rediscovering your own logic. 3. Include Visuals: Use charts or screenshots to illustrate key parts of your process.  A picture is worth a thousand lines of code!     4. Highlight Challenges and Solutions: Share what problems you faced and how you solved them. This not only showcases your problem-solving skills but also builds trust with your team. 5. Summarize Results:     Focus on outcomes and insights for business stakeholders, while also pointing out areas for further improvement for your fellow developers. Structure it like this: Introduction > Objectives > Methods > Results > Conclusion > Future Work. Clarity is key. Remember, understandable code is valuable code. Repost if you can relate to Sheldon ♻️ PS: Don’t be like Sheldon, don’t skip the manual! PPS: When was the last time you didn’t understand your old code?

🪂 How To Make Your Design System AI-Ready (https://lnkd.in/dtnpy7CM), a practical guide on how to reduce drifts, minimize mistakes, maintain context and improve the quality of AI-generated prototypes — with structured spec files, automated auditing and token layers. Put together by Hardik Pandya from Atlassian. --- 🔹 1. Design Decisions Are Infrastructure AI-generated prototypes often don't deliver consistently decent results because of tiny inconsistencies scattered all across a design system. Often it's decisions made but not documented, hard-coded values never cleaned up, or relying too much on AI making sense of mock-ups or design flows on its own. Unsurprisingly, better AI prototypes come from better data — but also from better human guidance. We shouldn’t assume that AI knows how to choose the right component, and how to design with accessibility in mind. It needs priorities, a clear path on how we make decisions, design principles, examples, do's and don'ts. In fact, we should treat design decisions as infrastructure. That means that every time we make a decision — not just a design decision, but even decision on how actually prioritize our work and how we make decisions around here — it must find a path into the spec file that is then consumed by AI. --- 🔶 2. Three Layers: Spec Files + Token Layer + Audit To ensure quality, we establish design principles, guidelines, rules in a form of “spec files”). It's structured Markdown files that include spacing rules, color choices, component usage guidelines, priorities etc. AI is going to read and reuse that spec file every time it's going to generate a prototype. Because the spec files are text files, it's much more cost-effective, but also much more accurate just because we don't rely on AI recognizing or decoding patterns from mock-ups, but gets specific guidelines instead. In fact, extending code is often a more effective way than generating code from mock-ups. Token layer lists and keeps updated all tokens used throughout the design system. AI always chooses from a closed set of named variables instead of inventing plausible values ad-hoc. An audit script catches what AI gets wrong. It scans the prototype and flags every hard-coded value and flags it if necessary. It can be a regular software doing that, with AI waiting for its feedback to come back. Finally, when a design system ships updates, a sync routine flags which spec files need updating. The goal is to make sure that AI always reads up-to-date, current specs, not the ones written against an outdated version. --- 🔺 3. Examples of AI-Ready Design Systems ⌾ Atlassian: https://lnkd.in/dVsGc3Cp ⌾ Carbon: https://lnkd.in/d4zq4WWb ⌾ CMS Design System: https://lnkd.in/dHHzV3en ⌾ Nordhealth: https://lnkd.in/d8C4j2ZA Yet again, AI can’t magically resolve technical debt or design debt — it needs guidance, decisions, priorities and principles.

I've spent at least 60' every day for the last couple of months vibe coding on Claude Code... and most of the time I did it wrong! Defining the right anatomy of the .claude/ folder has defined a before and an after on the quality of my side projects. Most new users skip the setup. They open Claude Code and start prompting raw. No structure. No rules. No memory. That's the mistake I did. The .claude folder is Claude's operating system for your project. Get it right and Claude stops guessing. Get it wrong and you spend half your time correcting it. Here's the anatomy that works: 👉 CLAUDE.md → Claude's instruction manual. Build commands, architecture decisions, conventions, gotchas. Keep it under 200 lines. This is your highest-leverage file. 👉 rules/ → When CLAUDE.md gets crowded, split by concern. code-style.md, testing.md, api-conventions.md. Scope rules to specific paths with YAML frontmatter so they only load when relevant. 👉 commands/ → Repeatable workflows as slash commands. Code review, issue fixing, deploy checks. They run shell commands and inject real output into the prompt. 👉 skills/ → Like commands but Claude triggers them automatically when the task matches. They're packages, not single files. 👉 agents/ → Isolated subagent personas with their own tools and model preferences. A code reviewer that only reads. A security auditor scoped to grep. 👉 settings.json → Permission control. What Claude can run freely, what it must ask about, what's blocked entirely. The part most people miss: there are two .claude folders. One in your project (committed, shared with the team) and one at ~/.claude/ (personal, global across all repos). The .claude folder is infrastructure. Treat it like one. Full guide in the article below in the comments 👇 #ai #claude

🚀 This is great! Meet TOON - the new language for talking to LLMs efficiently. If JSON was built for humans, TOON (Token-Oriented Object Notation) is built for machines that think in tokens. And in the world of AI, where every token has a cost, in speed, compute, and cash, that difference matters. What is TOON? A compact, deterministic format for structured data that eliminates redundant key names and expresses information in a tabular, columnar way that LLMs parse more reliably and cheaply. Think of it as “CSV for reasoning” clean, predictable, and made for token efficiency. 🧩 Let’s see it in action ------------------------------ Instead of this classic JSON bloat: { "orders": [ { "order_id": 101, "customer": "Emma", "total": 124.75, "status": "delivered" }, { "order_id": 102, "customer": "Raj", "total": 89.50, "status": "pending" }, { "order_id": 103, "customer": "Ava", "total": 42.10, "status": "cancelled" } ] } ------------------------------ TOON encodes it like this: orders[3]{order_id,customer,total,status}: 101,Emma,124.75,delivered 102,Raj,89.50,pending 103,Ava,42.10,cancelled ------------------------------ That’s ~45% fewer tokens, and it scales even better for larger datasets. Why TOON is brilliant Token-efficient: 30–60% reduction in prompt size LLM-friendly: Consistent, columnar layout makes pattern recognition easier for models Low-friction: Convert from JSON, use it in your prompt, decode back when needed Composable: Works beautifully inside RAG pipelines, multi-agent systems, and autonomous data flows As prompts evolve from “chatting with AI” to building reasoning pipelines, we need formats that keep up, not just humans reading data, but machines understanding context. TOON is a reminder that real innovation isn’t always about bigger models. Sometimes, it’s about rethinking the invisible layer that connects them all — the structure of information itself. Smaller prompts. Faster reasoning. Smarter agents.

𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰, 𝗢𝗽𝗲𝗻𝗔𝗜, 𝗚𝗼𝗼𝗴𝗹𝗲, 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁, 𝗖𝘂𝗿𝘀𝗼𝗿, 𝗮𝗻𝗱 𝗝𝗲𝘁𝗕𝗿𝗮𝗶𝗻𝘀 𝗮𝗴𝗿𝗲𝗲𝗱 𝗼𝗻 𝗼𝗻𝗲 𝘁𝗵𝗶𝗻𝗴 𝗶𝗻 𝟮𝟬𝟮𝟱. It wasn't a model. It was a file format. SKILL. md — an open standard from Anthropic (Dec 2025) — is now supported by 16+ AI coding tools. The format is universal. Only the directory path changes per vendor. Competing AI companies don't usually agree on much. So the interesting question is why they agreed on this one. 𝗧𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝗞𝗜𝗟𝗟. 𝗺𝗱 𝘀𝗼𝗹𝘃𝗲𝘀 Most builders stuff everything into CLAUDE. md or .cursorrules. Coding standards. API docs. Deployment steps. Security checklists. Style guides. Every session loads all of it. Even when 90% is irrelevant to the task at hand. Context bloat. Wasted tokens. Slower responses. And the bigger the team, the worse it gets. 𝗛𝗼𝘄 𝗦𝗞𝗜𝗟𝗟.𝗺𝗱 𝘄𝗼𝗿𝗸𝘀 — 𝗽𝗿𝗼𝗴𝗿𝗲𝘀𝘀𝗶𝘃𝗲 𝗱𝗶𝘀𝗰𝗹𝗼𝘀𝘂𝗿𝗲 → Level 1: Agent reads only the name + description (~30-50 tokens per skill) → Level 2: If the description matches the task, full SKILL. md body loads (under 5,000 tokens) → Level 3: Scripts and reference files load on demand Hundreds of skills become available to the agent. Zero context bloat. Tokens spent only when actually needed. This is the part most people miss. SKILL. md isn't a better prompt file. It's a routing system. 𝗧𝗵𝗲 𝗮𝗻𝗮𝘁𝗼𝗺𝘆 𝗶𝘀 𝘁𝗶𝗻𝘆 → YAML frontmatter with name and description → Markdown body with instructions → Optional folders: scripts/, references/, assets/ The description field is the trigger. Write it as a routing signal, not a summary. "Reviews pull requests for bugs, security issues, and code quality. Use when reviewing PRs or code changes." — that's a description that wins matches. "PR review skill" — that's a description that loses. 𝗦𝗸𝗶𝗹𝗹𝘀 𝘃𝘀 𝗖𝗼𝗻𝗳𝗶𝗴𝘀 𝘃𝘀 𝗠𝗖𝗣 → Skills: on-demand expertise, loaded when triggered → Configs (CLAUDE. md, .cursorrules): always-on context, loaded every session → MCP: external tools and services, loaded on startup They complement each other. Skills are where your workflows live. Configs are where your rules live. MCP is where your systems live. Stop treating them as alternatives. 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 𝗳𝗼𝗿 𝘁𝗲𝗮𝗺𝘀 A team's tacit knowledge has always lived in Slack threads, wiki pages, and senior engineers' heads. How to review a PR here. How to write a migration here. How to debug a flaky test here. How to ship to staging on a Friday without breaking everything. SKILL. md is the first format where that knowledge becomes portable, version-controlled, and agent-readable. Drop the folder. The agent gains the capability. Move tools. The skill comes with you. The format is the standard. The path is the only thing that changes.

𝗜𝗳 𝘆𝗼𝘂’𝗿𝗲 𝘀𝘁𝗶𝗹𝗹 𝗳𝗲𝗲𝗱𝗶𝗻𝗴 𝗿𝗮𝘄 𝗝𝗦𝗢𝗡 𝗶𝗻𝘁𝗼 𝗟𝗟𝗠𝘀, 𝘆𝗼𝘂 𝗺𝗶𝗴𝗵𝘁 𝗯𝗲 𝘄𝗮𝘀𝘁𝗶𝗻𝗴 𝘁𝗼𝗸𝗲𝗻𝘀, 𝗹𝗮𝘁𝗲𝗻𝗰𝘆, 𝗮𝗻𝗱 𝗺𝗼𝗻𝗲𝘆. This is something I see surprisingly often in AI systems. JSON works well for software systems. But for LLMs, it carries a lot of unnecessary structure. Recently I came across 𝗧𝗢𝗢𝗡 (Token-Oriented Object Notation), a format designed specifically for LLM workflows. And the difference is not subtle. Same dataset: → 𝟰𝟭𝟮 characters in JSON → 𝟭𝟱𝟰 characters in TOON Less structure noise. More useful information for the model. 𝗛𝗲𝗿𝗲’𝘀 𝘄𝗵𝗮𝘁 𝗧𝗢𝗢𝗡 𝗯𝗿𝗶𝗻𝗴𝘀 𝘁𝗼 𝘁𝗵𝗲 𝘁𝗮𝗯𝗹𝗲: ⬇️ → Token efficiency: often 30–60% fewer tokens for uniform datasets. → LLM-friendly structure: predictable fields improve model parsing. → Minimal syntax: fewer brackets, quotes, and repeated keys. → Flexible workflow: convert between JSON and TOON when needed. 𝗪𝗵𝗲𝗻 𝘀𝗵𝗼𝘂𝗹𝗱 𝘆𝗼𝘂 𝘂𝘀𝗲 𝗶𝘁? ⬇️ → Large structured datasets such as logs, catalogs, telemetry, user lists. → Systems where token cost and latency matter. For deeply nested or irregular data, JSON still makes sense. But if you are building AI agents, copilots, or automation systems, the format of your data suddenly matters much more than it used to. For years we optimized models. Now we are starting to optimize how we talk to them. 𝗖𝘂𝗿𝗶𝗼𝘂𝘀: 𝗗𝗼 𝘆𝗼𝘂 𝘁𝗵𝗶𝗻𝗸 𝗟𝗟𝗠-𝗻𝗮𝘁𝗶𝘃𝗲 𝗱𝗮𝘁𝗮 𝗳𝗼𝗿𝗺𝗮𝘁𝘀 𝗹𝗶𝗸𝗲 𝗧𝗢𝗢𝗡 𝗰𝗼𝘂𝗹𝗱 𝗯𝗲𝗰𝗼𝗺𝗲 𝘁𝗵𝗲 𝗻𝗲𝘅𝘁 𝘀𝘁𝗮𝗻𝗱𝗮𝗿𝗱? #AI #LLM #AgenticAI #DataEngineering #ArtificialIntelligence

🛠️🤖 How to build AI agents from scratch (Even if you've never done it before.) 𝗧𝗵𝗲𝘀𝗲 𝗮𝗿𝗲 𝘁𝗵𝗲 𝟵 𝘀𝘁𝗲𝗽𝘀 𝘁𝗼 𝘁𝗮𝗸𝗲, 𝗳𝗿𝗼𝗺 𝗽𝘂𝗿𝗽𝗼𝘀𝗲 𝘁𝗼 𝗨𝗜. - - - - 𝗦𝗧𝗘𝗣 𝟭 - 𝗦𝗘𝗧 𝗬𝗢𝗨𝗥 𝗔𝗚𝗘𝗡𝗧'𝗦 𝗣𝗨𝗥𝗣𝗢𝗦𝗘 𝗔𝗡𝗗 𝗦𝗖𝗢𝗣𝗘 • Identify your target users • Clarify what deliverable it will produce • Define the specific task your agent will handle    → Example: Sales assistant that qualifies leads, researches prospects, and drafts outreach emails 𝗦𝗧𝗘𝗣 𝟮 - 𝗖𝗥𝗘𝗔𝗧𝗘 𝗖𝗟𝗘𝗔𝗥 𝗜𝗡𝗣𝗨𝗧/𝗢𝗨𝗧𝗣𝗨𝗧 𝗦𝗧𝗥𝗨𝗖𝗧𝗨𝗥𝗘 • Build structured data schemas using tools like Pydantic • Design API-like inputs and outputs • Avoid unstructured text responses    → Tools: Pydantic, JSON Schema, TypeScript interfaces 𝗦𝗧𝗘𝗣 𝟯 - 𝗪𝗥𝗜𝗧𝗘 𝗧𝗛𝗘 𝗦𝗬𝗦𝗧𝗘𝗠 𝗜𝗡𝗦𝗧𝗥𝗨𝗖𝗧𝗜𝗢𝗡𝗦 • Create detailed role descrip & behavioral guidelines • Use prompting techniques for reliable responses • Test different instruction formats    → Tools: Claude, GPT-4, custom prompt libraries 𝗦𝗧𝗘𝗣 𝟰 - 𝗘𝗡𝗔𝗕𝗟𝗘 𝗥𝗘𝗔𝗦𝗢𝗡𝗜𝗡𝗚 𝗔𝗡𝗗 𝗘𝗫𝗧𝗘𝗥𝗡𝗔𝗟 𝗔𝗖𝗧𝗜𝗢𝗡𝗦 • Implement decision-making frameworks like ReAct • Connect to external APIs and databases • Add web browsing, calc, file processing    → Tools: OpenAI Functions, Anthropic Tools, custom APIs 𝗦𝗧𝗘𝗣 𝟱 - 𝗢𝗥𝗖𝗛𝗘𝗦𝗧𝗥𝗔𝗧𝗘 𝗠𝗨𝗟𝗧𝗜𝗣𝗟𝗘 𝗔𝗚𝗘𝗡𝗧𝗦 (𝗪𝗛𝗘𝗡 𝗡𝗘𝗘𝗗𝗘𝗗) • Design agent teams with specialized roles • Build coordination logic between different agents • Create workflows for complex multi-step processes    → Tools: AutoGen, CrewAI, custom orchestration 𝗦𝗧𝗘𝗣 𝟲 - 𝗜𝗠𝗣𝗟𝗘𝗠𝗘𝗡𝗧 𝗠𝗘𝗠𝗢𝗥𝗬 𝗔𝗡𝗗 𝗖𝗢𝗡𝗧𝗘𝗫𝗧 • Add conversation history tracking • Build knowledge retrieval systems • Store and recall relevant past interactions    → Tools: Vector databases, conversation buffers, RAG systems 𝗦𝗧𝗘𝗣 𝟳 - 𝗜𝗡𝗧𝗘𝗚𝗥𝗔𝗧𝗘 𝗠𝗨𝗟𝗧𝗜𝗠𝗘𝗗𝗜𝗔 𝗖𝗔𝗣𝗔𝗕𝗜𝗟𝗜𝗧𝗜𝗘𝗦 • Add speech processing for voice interactions • Support document and video understanding • Enable image analysis and generation    → Tools: Whisper, DALL-E, GPT-4 Vision 𝗦𝗧𝗘𝗣 𝟴 - 𝗙𝗢𝗥𝗠𝗔𝗧 𝗔𝗡𝗗 𝗗𝗘𝗟𝗜𝗩𝗘𝗥 𝗥𝗘𝗦𝗨𝗟𝗧𝗦 • Structure outputs for both humans and systems • Generate reports, summaries, actionable items • Ensure results are properly formatted    → Tools: Markdown processors, PDF generators, structured data formats 𝗦𝗧𝗘𝗣 𝟵 - 𝗕𝗨𝗜𝗟𝗗 𝗨𝗦𝗘𝗥 𝗜𝗡𝗧𝗘𝗥𝗙𝗔𝗖𝗘 𝗢𝗥 𝗔𝗣𝗜 • Create web interfaces for user interaction • Expose functionality through REST APIs • Deploy as chatbots or integrated tools    → Tools: React, FastAPI, Streamlit, Gradio - - - - Ready to go further? I cover 10x more detail here: https://lnkd.in/eeey5Cxr 2025 is the year of AI agents. You got this 💪, Aakash P.S. What agents are you building?

Claude Code is a 5-layer operating system. Not features. Not settings. Layers. Most people use one layer and call it a day. Ask a question, get an answer, close the tab. But the layers aren't a menu you pick from. They stack. And stacked, they multiply. One layer saves you minutes. Five layers working together replace a team. I've spent months building with this exact stack. Here's each layer, in plain words 👇 (See the visual from Brij Kishore Pandey for the full map) 1️⃣ CLAUDE.md - the Memory Layer ↳ These are your house rules. Written down once. ↳ The AI reads them every time. So it never forgets how you work. ↳ Every other layer uses these rules for free. 2️⃣ Skills - the Knowledge Layer ↳ A how-to guide for one (repeatable) job. ↳ The AI grabs it only when it's needed. ↳ Bonus: each skill can run on its own. Your main chat stays clean. 3️⃣ Hooks - the Guardrail Layer ↳ Like a fence. Strict, and reliable. ↳ "Block that." "Check this." "Send an alert." ↳ They run by themselves. No thinking needed. They keep your rules safe. 4️⃣ Subagents - the Delegation Layer ↳ Each one does a single job. ↳ A checker. A tester. A finder. ↳ They work off to the side. Your main chat stays focused. 5️⃣ Plugins - the Distribution Layer ↳ Box up everything above. ↳ Send it to your whole team in one click. ↳ Now everyone runs the same setup. Two things wire the whole stack together: 🔌 MCP Servers give every layer hands. ↳ GitHub, databases, APIs, and custom integrations, reachable from any layer. 👥 Agent Teams let your subagents run in parallel. ↳ Message passing, shared permissions, one agent lead orchestrating the rest. Here's the big idea most people miss. One layer is just a setting. Five layers, wired to your tools and running in parallel, is an operating system. They don't add up. They multiply. Save this so you can build your stack one layer at a time. Which layer are you not using yet? Drop a comment below. ♻️ Repost to help other builders level up their AI stack. And follow Basia Kubicka for more on building in the AI era. ====== Join a FREE workshop on July 28th: Voice Agents in Production: Latency & Evals at Enterprise Scale RSVP here: https://lnkd.in/gm4wxnKe

"AI writes code faster. Your job is still to prove it works." My latest free write-up: https://lnkd.in/gkhzcfiR ✍ is all about code review. Over 30% of senior developers now ship mostly AI-generated code. The problem? AI excels at drafting features but stumbles on logic, security, and edge cases - with errors 75% more common in logic alone. The bottleneck has moved from writing code to proving it works. What's changing: Solo devs ship at "inference speed," treating AI like a powerful intern - but the smart ones have built verification systems (high test coverage, manual testing) that catch issues before production. Skip review and you don't eliminate work, you defer it. Teams face a different challenge: AI floods volume. PRs are ~18% larger, incidents per PR up ~24%, change failure rates up ~30%. When output increases faster than verification capacity, review becomes the rate limiter. Security remains non-negotiable for human oversight. ~45% of AI-generated code contains security flaws. Logic errors at 1.75× the rate of human code. XSS vulnerabilities at 2.74×. The emerging best practice? A simple PR contract: → What/why in 1-2 sentences → Proof it works (tests, screenshots, logs) → Risk tier + which parts were AI-generated → Where you need human input If you can't fill this out, you don't understand your own change well enough to ask someone to approve it. Proof over vibes. The human is ultimately responsible for what the AI delivers. #ai #programming #softwareengineering

𝗔𝗻𝘁𝗵𝗿𝗼𝗽𝗶𝗰 𝗰𝗿𝗲𝗮𝘁𝗲𝗱 𝗮𝗻 𝗼𝗽𝗲𝗻 𝘀𝘁𝗮𝗻𝗱𝗮𝗿𝗱 𝗳𝗼𝗿 𝗔𝗜 𝗰𝗼𝗱𝗶𝗻𝗴 𝗮𝗴𝗲𝗻𝘁𝘀. ⬇️ 𝗜𝘁'𝘀 𝗰𝗮𝗹𝗹𝗲𝗱 𝗦𝗞𝗜𝗟𝗟. 𝗺𝗱. And even after reading many tutorials and how-to guides, this official 33-page guide on Claude Skills remains one of the best sources. 𝗙𝗶𝗿𝘀𝘁, 𝘄𝗵𝗮𝘁 𝗶𝘀 𝗮 𝗖𝗹𝗮𝘂𝗱𝗲 𝗦𝗸𝗶𝗹𝗹?  A Skill is a folder that teaches Claude a workflow. You set it up once, then it’s reusable across sessions. At its core, it’s a set of instructions that teaches Claude how to do a specific task your way. Think of it like handing a new employee your playbook on day one. Except they never forget it. And all is written down in a markdown file (SKILL.md). This keeps your workflow maintainable over time. It reduces prompt bloat and inconsistency And it makes iteration easier because you can tighten one thing without breaking everything else The guide itself is well scoped, covering the following areas: 1 - Fundamentals 2 - Planning and design 3 - Testing and iteration 4 - Distribution and sharing 5 - Patterns and troubleshooting Some very important take aways here: ✦ Build micro-skills that chain together instead of one monolithic skill ✦ Keep SKILL.md short and decisive, move supporting material into references/ and assets ✦ Always hand-edit Skills generated by Claude, first drafts are usually too verbose to be reliable ✦ The real leverage comes when Skills connect to tools through hooks and MCP servers, that’s when “workflow” turns into “system” If you are building agents, internal copilots, or repeatable personal workflows in 2026, Skills are worth learning properly. 𝗣.𝗦.: 𝗜𝗳 𝘆𝗼𝘂 𝘄𝗮𝗻𝘁 𝗺𝘆 𝗮𝗴𝗲𝗻𝘁𝗶𝗰 𝗔𝗜 𝗽𝗹𝗮𝘆𝗯𝗼𝗼𝗸, 𝘀𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲 𝘁𝗼 𝗺𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿. 𝟯𝟬,𝟬𝟬𝟬+ 𝗽𝗲𝗼𝗽𝗹𝗲 𝗮𝗿𝗲 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝗶𝗻𝘀𝗶𝗱𝗲: https://lnkd.in/dbf74Y9E Some further good ressources from Anthropic: ✦ Best practices guide: https://lnkd.in/gGpcN8nQ ✦ Skills documentation: https://lnkd.in/gevQn-5a ✦ Example skills: https://lnkd.in/gd7eZDaH