DEV Community: Ramandeep Singh

Project Portfolio Agent using Cursor

Ramandeep Singh — Mon, 27 Jul 2026 04:35:18 +0000

How I Automated My Project Portfolio with a Custom Cursor Agent

Managing an up-to-date project portfolio used to be a manual and tedious task—until I built my own agent in Cursor IDE to automate the process. Here’s how I set it up:

Switched to Plan Mode in Cursor: I started by enabling Plan Mode in the Cursor IDE, which is designed for creating, managing, and running agents.
Provided Relevant Context: I fed the agent all necessary context about my workspace, including where my portfolio data lives and how my projects are structured.
Generated an Agent Configuration: Using Cursor’s planning tools, I generated an agent .mdc configuration file and placed it in the .cursor directory of my project.
Defined Custom Rules: I wrote specific rules for my agent—such as how to recognize new projects, update descriptions, or remove deprecated entries—to ensure it could handle my preferred workflows.
Activated the Agent: With everything in place, I activated the agent. From here on out, it runs automatically whenever I’m working in the IDE.
Effortless Project Management: Now, to add, remove, or update projects in my portfolio, I simply instruct the agent in natural language and it takes care of the rest—keeping my portfolio perfectly synced and up to date without the manual hassle.

This setup lets me focus on building new projects instead of constantly updating my portfolio by hand!

Strands Self-healing Agent for Remote server

Ramandeep Singh — Wed, 22 Jul 2026 11:34:44 +0000

Here’s what you need on the remote Linux server -

1. Linux host with SSH

Any systemd Linux box (Ubuntu/RHEL/etc.) reachable from the agent machine
OpenSSH server running (sshd)
Port 22 (or your chosen port) open from the agent host

2. Demo service (systemd unit)

Create a real service the agent can stop/start — e.g. billing-api.service:

# Example unit: /etc/systemd/system/billing-api.service
sudo systemctl daemon-reload
sudo systemctl enable --now billing-api.service
sudo systemctl status billing-api.service --no-pager

It should produce logs matching the story (startup lines, health checks, errors on crash).

3. SSH account for the agent

Dedicated user (e.g. ops-agent)
Key-based auth preferred (private key on agent side, public key in ~/.ssh/authorized_keys)
Permission to run at least:
- systemctl is-active <service>
- systemctl status <service>
- systemctl stop <service> / systemctl start <service> (often via passwordless sudo)

Example sudoers (least privilege):

ops-agent ALL=(root) NOPASSWD: /bin/systemctl is-active billing-api.service, /bin/systemctl status billing-api.service, /bin/systemctl stop billing-api.service, /bin/systemctl start billing-api.service, /bin/systemctl restart billing-api.service

4. Logs readable over SSH

Journal access for that unit (journalctl -u billing-api.service), and/or
App log path as in the story (e.g. /var/log/billing-api/application.log) readable by the SSH user

5. Smoke-test from your laptop/agent host

ssh ops-agent@<server-ip>
systemctl is-active billing-api.service
systemctl status billing-api.service --no-pager
sudo systemctl stop billing-api.service
sudo systemctl start billing-api.service

6. Demo trigger prep

Before the demo, stop the service (or crash it) so the alert is real:

sudo systemctl stop billing-api.service

Then the agent SSH’s in, sees failed/inactive, restarts, and confirms from status + logs.

Agent side (from setup.txt): point Strands SshSandbox (or constrained tools) at that host with host, identity_file, and port — the remote box itself doesn’t need Strands installed.

NVIDIA - NIM Free Image generation Model PS scripts

Ramandeep Singh — Wed, 22 Jul 2026 06:30:11 +0000

Checkout the Git Repository
PowerShell scripts in nim-image-gen, one per NVIDIA NIM model:

Script	Model	Notable defaults
`flux1-dev.ps1`	`black-forest-labs/flux.1-dev`	50 steps, 1024×1024
`flux1-schnell.ps1`	`black-forest-labs/flux.1-schnell`	4 steps (fast)
`sd-3.5-large.ps1`	`stabilityai/stable-diffusion-3.5-large`	`text_prompts` format, cfg 5.0
`sdxl.ps1`	`stabilityai/stable-diffusion-xl`	`text_prompts` format, sampler `K_DPMPP_2M`
`sdxl-turbo.ps1`	`stabilityai/sdxl-turbo`	1 step, cfg 0 (real-time)

Shared design:

Each takes params: -ApiKey, -Prompt, -Out, -Seed (+ model-specific ones like -Steps, -Width, -Height, -CfgScale).
API key falls back to $env:NVIDIA_API_KEY if -ApiKey isn't passed.
Forces TLS 1.2 (for Windows PowerShell 5.1), has try/catch error handling that prints the API's error body, validates the response, and decodes base64 → PNG.
FLUX scripts use the prompt field; Stability scripts use the text_prompts array format.

Usage example:

cd nim-image-gen
$env:NVIDIA_API_KEY = "nvapi-xxxx"
.\flux1-dev.ps1 -Prompt "a red fox in autumn leaves" -Out fox.png

One caveat: endpoint slugs and exact request fields on NVIDIA NIM change occasionally. If any script returns a 4xx, open that model's page on build.nvidia.com and confirm the URL/fields — set sensible defaults based on NIM's common conventions, but the Stability field names (text_prompts, cfg_scale, sampler) in particular are worth a quick check.

NVIDIA NIM Free Image generation Models

Ramandeep Singh — Wed, 22 Jul 2026 06:23:55 +0000

Since we've been on image generation, here are the main free image models — grouped by how you'd access them.

Free via NVIDIA NIM (build.nvidia.com)

These work with the exact same PowerShell/curl pattern I gave you — just swap the endpoint:

Model	Endpoint slug	Notes
FLUX.1 [dev]	`black-forest-labs/flux.1-dev`	Top-tier quality, great prompt adherence
FLUX.1 [schnell]	`black-forest-labs/flux.1-schnell`	Much faster, fewer steps (~4)
Stable Diffusion 3.5 Large	`stabilityai/stable-diffusion-3.5-large`	Strong all-rounder
SDXL	`stabilityai/stable-diffusion-xl`	Older but reliable, lots of community LoRAs
SDXL Turbo	`stabilityai/sdxl-turbo`	Real-time / single-step generation

Free to run locally (open weights, on your NVIDIA GPU)

Fully free, unlimited, private — just needs VRAM:

FLUX.1 [schnell] — Apache-2.0 licensed, the most permissive top model
Stable Diffusion 3.5 Medium / Large — runs well on 8–12GB VRAM (medium)
SDXL / SDXL-Lightning — light, fast, huge ecosystem
SD 1.5 — ancient by now but tiny, runs on almost anything
Playground v2.5 — aesthetically tuned, open weights
Kandinsky 3 — open, good stylized output

Quick recommendation

Goal	Pick
Best quality, free, no GPU	FLUX.1-dev via NVIDIA NIM
Fastest results	FLUX.1-schnell or SDXL-Turbo
Unlimited + private	FLUX.1-schnell locally (Apache license)
Zero setup, zero key	Pollinations.ai

NIM Free Models vs Cursor IDE

Ramandeep Singh — Wed, 22 Jul 2026 05:49:05 +0000

What each option actually is

Cursor Pro ($20/mo) — You're not just paying for "an AI model." You're paying for:

The agent harness (this whole system: tool-calling, codebase indexing, multi-file edits, terminal control, apply models, etc.)
Frontier models (Claude Opus/Sonnet, GPT, Gemini) that are not open source and are very expensive to run
Fast, managed inference with no setup

Free NVIDIA open-source models — This usually means one of two things:

build.nvidia.com (NIM APIs) — free-tier API access to hosted open models (Llama, DeepSeek, Qwen, Nemotron, etc.) with rate limits
Running open models locally on your own NVIDIA GPU (via Ollama, vLLM, LM Studio, etc.)

The honest tradeoffs

Factor	Cursor Pro	Free NVIDIA / Open-source
Model quality for coding	Frontier (best available)	Good and closing the gap (Qwen3-Coder, DeepSeek-V3, etc.) but still behind Opus/Sonnet on hard agentic tasks
Cost	$20/mo	$0 (API free tier) or hardware cost (local)
Agent capabilities	Full agentic IDE, tool use, indexing	You lose this unless you wire it up yourself
Rate limits	Generous	NIM free tier is limited; local is unlimited but slow
Privacy	Cloud	Local = fully private
Setup effort	Zero	Moderate to high (esp. local)

The key insight most people miss

The model is only half the value. Cursor's real product is the agent + IDE integration. If you take a free open-source model and use it inside a basic chat UI, you're not getting a comparable experience to Cursor — you're getting a chatbot.

If you want to use free/open models and keep an agentic coding workflow, your realistic paths are:

Cursor with a custom API key / model — you can add your own OpenAI-compatible endpoint (including NVIDIA NIM) in Cursor settings and route to open models. You keep the harness, swap the model. (Note: some Cursor features like fast apply/tab are tied to their own models.)
Open-source agent tools — e.g. Cline, Continue.dev, Aider, or the Cursor-like OSS clones, pointed at a NIM endpoint or local Ollama.

Practical recommendation

You do heavy/professional coding → $20 Cursor Pro is a genuine bargain. The frontier models alone would cost far more via raw API usage, and the agent is worth it.
You're cost-sensitive, hobbyist, or privacy-focused → Free NVIDIA NIM or a local Qwen3-Coder/DeepSeek setup with Aider/Cline is very capable and $0.
Best of both → Keep Cursor but experiment with adding a NIM/open-model endpoint for cheap/bulk tasks, saving frontier calls for hard problems.

What “top down” usually means for a PM

Ramandeep Singh — Tue, 14 Jul 2026 05:30:32 +0000

Your manager is likely saying you start (or stay) too close to details, features, or execution, and not enough from:

Business outcome — What problem are we solving, and why does it matter now?
Strategic context — How does this connect to company goals, OKRs, or product vision?
Tradeoffs at the right altitude — What are we choosing not to do, and why?
Narrative for leadership — Can you explain the work in 30 seconds without mentioning tickets or UI?

Top down: “We need to reduce churn in enterprise accounts because renewal risk is up 12%. The highest-leverage bet is improving onboarding for admins in the first 14 days.”

Bottom up (what they may be hearing): “We should add a dashboard widget, fix these 5 bugs, and ship the export feature users asked for.”

Both can be true — the issue is often where you begin and how you justify the work.

How to practice top-down thinking

1. Use a simple framing template

Before any recommendation, force this structure:

Context: What’s happening in the business/market?
Problem: What’s broken or missing (one sentence)?
Impact: What happens if we don’t solve it?
Proposal: What’s the smallest bet that moves the needle?
Success: How will we know it worked?

2. Lead with the “so what”

In docs, Slack, and meetings, put the headline first:

“Recommendation: Deprioritize Feature X this quarter to protect enterprise retention.

Reason: 3 of our top 10 accounts flagged onboarding friction as a renewal risk.”

Then add details — not the other way around.

3. Tie everything to a north star

For each initiative, be able to answer:

Which goal/OKR does this serve?
What metric moves?
What’s the counterfactual (what we give up)?

If you can’t answer those, you’re still thinking bottom-up.

4. Zoom out before zooming in

When you get a request (from users, sales, eng), ask:

Is this a symptom of a bigger problem?
How many users/accounts does this affect?
Is this urgent, important, or just loud?

5. Practice the “executive version”

Take your current roadmap item and rewrite it as:

1 slide title
3 bullets (problem, approach, outcome)
1 risk

If that’s hard, the thinking isn’t top-down yet.

A useful mental model

Strategy (why / where to play)
    ↓
Outcomes (what success looks like)
    ↓
Bets (which problems to solve)
    ↓
Solutions (features, specs, tickets)

If you live mostly at the bottom two layers, you’ll get this feedback — even if you’re doing good PM work day to day.

Bottom line

“Think top down” usually means: start from outcomes and strategy, then derive work — and lead conversations that way.

Your next step isn’t to think less about details; it’s to anchor details to a clear higher-level story every time you propose, prioritize, or update.

I turned my daily job hunt into a semi-automated workflow in Cursor.

Ramandeep Singh — Tue, 14 Jul 2026 05:23:11 +0000

Every morning used to look the same: scroll LinkedIn alerts → open a JD → tailor my resume → Easy Apply or an external form → repeat. Lots of context-switching, easy to miss steps, and hard to track what I already applied to.

So I documented the whole process in a resume + application workspace:

What the agent does

Scans today’s LinkedIn job listings (Browser MCP)
Saves each JD and scores fit against my base resume
Tailors a truthful, JD-aligned resume (no invented experience)
Exports a PDF and pre-fills Easy Apply / external forms

What I still do

Review the tailored resume and fit score
Answer role-specific questions
Click Submit (by design — I stay in control)

What’s in the repo

base-resume.md — single source of truth
RUNBOOK.md — step-by-step daily batch
jobs/<company-role>/ — JD, analysis, tailored resume, PDF
applications.csv + queue — no duplicate applies
Cursor rules so tailoring stays consistent every run

One prompt to start the day:

Run today's job application batch per RUNBOOK.md

It’s not “auto-apply everything.” It’s prep at machine speed, decisions at human speed — which is how I want to job search as a PM.

If you’re job hunting with Cursor, I’d start with a runbook + a base resume + a hard rule: never submit without you.

Shorter version (if you prefer punchy)

Job search loop, documented in Cursor:

Discover → extract JD → fit score → tailor resume → PDF → Easy Apply prep → I click Submit.

Everything lives in a workspace: base resume, per-job folders, application log, and a RUNBOOK.md the agent follows daily.

Semi-automated, not reckless — speed on prep, judgment on submit.

I turned my daily job hunt into a semi-automated workflow in Cursor.

Ramandeep Singh — Thu, 21 May 2026 08:56:34 +0000

Every morning used to look the same: scroll LinkedIn alerts -> open a JD -> tailor my resume -> Easy Apply or an external form -> repeat. Lots of context-switching, easy to miss steps, and hard to track what I already applied to.

So I documented the whole process in a resume + application workspace:

What the agent does

Scans today’s LinkedIn job listings (Browser MCP)
Saves each JD and scores fit against my base resume
Tailors a truthful, JD-aligned resume (no invented experience)
Exports a PDF and pre-fills Easy Apply / external forms

What I still do

Review the tailored resume and fit score
Answer role-specific questions
Click Submit (by design - I stay in control)

What’s in the repo

base-resume.md — single source of truth
RUNBOOK.md — step-by-step daily batch
jobs/<company-role>/ — JD, analysis, tailored resume, PDF
applications.csv + queue — no duplicate applies
Cursor rules so tailoring stays consistent every run

One prompt to start the day:

Run today's job application batch per RUNBOOK.md

It’s not “auto-apply everything.” It’s prep at machine speed, decisions at human speed - which is how I want to job search as a PM.

If you’re job hunting with Cursor, I’d start with a runbook + a base resume + a hard rule: never submit without you.

Multi-Tasking Your Job Applications

Ramandeep Singh — Thu, 21 May 2026 08:49:21 +0000

The problem

Job applications are more demanding than ever. Long JDs, narrow requirements, and role-specific screening mean a one-size-fits-all resume no longer works — you have to tailor for every role.

On top of that:

Easy Apply and ATS forms add assessment questions that eat time
Some roles need cover letters, portfolios, or extra documents
A single application can easily take 1–2 hours — with no guarantee you pass the first screen

That friction adds up fast when you're applying at volume.

What I tried

I hit the same wall — so I used Cursor's Agent to turn my manual loop into a semi-automated workspace.

The outcome: search, evaluate, tailor, and prep ~10 applications in about an hour — instead of spending most of that time on one role.

What made the difference:

Multi-tasking — parallel resume tailoring while the agent handles discovery
Ask + project workspace — one repo for base resume, JDs, fit analysis, PDFs, and logs
In-IDE browser automation — the agent navigates LinkedIn; I get summaries from many job pages in one view and decide where to invest effort before I apply

I still click Submit — the agent stops at the checkpoint. That keeps quality and judgment in my hands while automation does the repetitive prep.

How it's set up

Everything is documented in a small project:

RUNBOOK.md — daily job-application batch (discover → JD → tailor → PDF → apply prep)
/multitask — tailor multiple resumes in parallel instead of one-by-one
Simple commands I use in chat:
- Run today's job application batch per RUNBOOK.md
- applied <slug> or skipped <slug> (log what I actually submitted)
- continue batch (pick up where I left off)

Instead of a strict sequential loop, I can run tailoring in parallel with /multitask while discovery and apply-prep move on other tracks.

Takeaway

This isn't "auto-apply and forget." It's multi-tasking the boring parts — JD capture, fit check, resume tailoring, form pre-fill — so I spend my hour on decisions, not copy-paste.

If you're job hunting in 2026, a runbook + agent + browser MCP + one workspace is a practical way to scale applications without burning out.

Online Assembly Language Learning Resources

Ramandeep Singh — Thu, 23 Apr 2026 04:21:39 +0000

In case traditional assembly tools (NASM, GCC) are not installed on your local system, here are online alternatives that you can use immediately:

Online Assembly Compilers & Simulators

1. Compiler Explorer (Godbolt)

URL: https://godbolt.org/
Features:
- Supports x86-64, ARM, and other architectures
- Real-time compilation and assembly output
- Multiple compiler options (GCC, Clang, MSVC)
- Interactive assembly learning

2. OnlineGDB

URL: https://www.onlinegdb.com/
Features:
- Online C/C++ compiler with assembly output
- Debugging capabilities
- Multiple language support

3. Replit

URL: https://replit.com/
Features:
- Online IDE with NASM support
- Collaborative coding
- Multiple programming languages

4. TutorialsPoint Online Compiler

URL: https://www.tutorialspoint.com/compile_assembly_online.php
Features:
- Dedicated assembly compiler
- Simple interface
- Good for beginners

Learning Platforms

1. Assembly Language Tutorials

CS50 Harvard: https://cs50.harvard.edu/x/2023/notes/4/
MIT OpenCourseWare: Assembly language courses
YouTube: Search for "assembly language tutorial"

2. Interactive Learning

Codecademy: Assembly language basics
Coursera: Computer architecture courses
edX: MIT and other university courses

Quick Start with Online Tools

Using Compiler Explorer:

Go to https://godbolt.org/
Select "x86-64 gcc" as compiler
Write a simple C program:

#include <stdio.h>
int main() {
    printf("Hello, World!\n");
    return 0;
}

View the assembly output in the right panel
Experiment with different optimizations

Using OnlineGDB:

Go to https://www.onlinegdb.com/
Select "C" as language
Write your C program
Compile and run
Use the "Debug" feature to see assembly

Recommended Learning Path

Start with C to Assembly: Write simple C programs and examine the assembly output
Learn Basic Instructions: MOV, ADD, SUB, JMP, etc.
Understand Registers: AX, BX, CX, DX, etc.
Practice with Online Simulators: Use the tools above
Progress to Complex Programs: Loops, functions, system calls

Installation Guide (Optional)

If you want to install assembly tools locally:

Option 1: Install NASM and GCC

Download NASM from: https://www.nasm.us/
Install MinGW-w64 for GCC: https://www.mingw-w64.org/
Add to PATH environment variable

Option 2: Install Visual Studio

Download Visual Studio Community (free)
Install with C++ development tools
Use MASM (Microsoft Macro Assembler)

Option 3: Use WSL (Windows Subsystem for Linux)

Install WSL from Microsoft Store
Install Ubuntu or other Linux distribution
Install NASM and GCC in Linux environment

Building AI Agents Has Never Been This Easy: Meet Strands Agent SDK

Ramandeep Singh — Wed, 22 Apr 2026 08:19:34 +0000

Stop wrestling with complex agent frameworks. Start building intelligent AI agents in minutes, not weeks.

The Problem Every Developer Faces

Picture this: You've got a brilliant idea for an AI agent that can help your users. Maybe it's a customer support bot that actually understands context. Or a research assistant that can analyze documents and provide insights. Or perhaps a multi-agent system where specialized agents collaborate to solve complex problems.

You're excited. You start coding. And then... reality hits.

You spend days (or weeks) wrestling with:

Complex orchestration logic
Integrating multiple AI model providers
Building tool calling mechanisms from scratch
Managing agent state and memory
Setting up observability and monitoring
Coordinating multiple agents in a system

By the time you've built the infrastructure, you've forgotten why you started in the first place. The actual agent logic? That's buried under layers of boilerplate code.

There has to be a better way.

Enter Strands Agent SDK

The Strands Agent SDK is an open-source, model-driven framework that flips the script entirely. Instead of spending weeks building infrastructure, you can create production-ready AI agents in minutes.

Think of it as the difference between building a car from scratch versus having a well-designed chassis where you just add the engine and wheels. Strands gives you the chassis—robust, tested, and ready to go.

Why Strands Stands Out

🚀 Lightweight Yet Powerful

Most agent frameworks force you into rigid patterns. Strands gives you a clean, straightforward agent loop that works beautifully out of the box—but you can customize every part of it when you need to.

from strands import Agent
from strands_tools import calculator

# That's it. You just created an AI agent.
agent = Agent(tools=[calculator])
response = agent("What is the square root of 1764?")
print(response)  # "The square root of 1764 is 42."

No configuration files. No complex setup. Just import, create, and use.

🎯 Model Agnostic (Finally!)

Tired of being locked into one AI provider? Strands supports them all:

Amazon Bedrock - Access to Claude, Llama, Titan, and more
Anthropic - Direct Claude integration
OpenAI - GPT-4, GPT-3.5, and beyond
Google Gemini - Latest models from Google
Ollama - Run models locally
LiteLLM - Unified interface to 100+ models
Custom providers - Bring your own

Switch models with a single parameter change. Compare performance across providers. Never get vendor-locked again.

🤝 Multi-Agent Systems Made Simple

Here's where Strands really shines. Building multi-agent systems is notoriously complex. But with Strands, you can create agent swarms where each agent has a specialized role:

from strands import Agent

# Research agent
researcher = Agent(
    name="Researcher",
    role="Gather and analyze information"
)

# Creative agent
creator = Agent(
    name="Creator", 
    role="Generate creative content"
)

# Critic agent
critic = Agent(
    name="Critic",
    role="Review and provide feedback"
)

# They work together automatically

Agents can collaborate, share context, and build on each other's work. It's like having a team of specialists working together—except they're AI agents, and they never get tired.

🔧 Built-in MCP Support

The Model Context Protocol (MCP) gives you access to a vast ecosystem of pre-built tools. Need to search the web? Check the weather? Query a database? There's probably an MCP tool for it.

Strands has native MCP support, so you can leverage this entire ecosystem without writing custom integrations.

☁️ AWS-Native (But Not AWS-Only)

Strands originated from AWS, so it has deep integration with AWS services:

Amazon Bedrock - Seamless access to foundation models
AWS X-Ray - Distributed tracing for debugging
CloudWatch - Real-time monitoring and logging
Direct AWS service calls - Your agents can interact with DynamoDB, S3, Lambda, and more

But here's the thing: it works great outside AWS too. Use it with any provider, anywhere.

Real-World Use Cases

Customer Support Agent

from strands import Agent
from strands_tools import web_search, database_query

support_agent = Agent(
    name="SupportBot",
    tools=[web_search, database_query],
    instructions="You are a helpful customer support agent..."
)

# Handle customer queries
response = support_agent("I need help with my order #12345")

Research Assistant

research_agent = Agent(
    name="ResearchAssistant",
    tools=[web_search, calculator],
    instructions="Analyze information and provide insights..."
)

insights = research_agent(
    "Research the latest trends in renewable energy and summarize key findings"
)

Multi-Agent Content Creation

Create a team of agents that work together:

Researcher gathers information
Writer creates the content
Editor reviews and refines
Publisher formats and publishes

All coordinated automatically by Strands.

Getting Started in 5 Minutes

Step 1: Install

pip install strands-agents strands-agents-tools

Step 2: Create Your First Agent

from strands import Agent
from strands_tools import calculator

agent = Agent(tools=[calculator])

Step 3: Use It

result = agent("Calculate 15% of 250")
print(result)

That's it. You're now building AI agents.

What Makes This Different?

You might be thinking: "There are other agent frameworks. What makes Strands special?"

Here's the honest answer:

Simplicity without sacrificing power - Easy to start, powerful enough to scale
True model flexibility - Not just "we support multiple models" but "switch models like changing a variable"
Production-ready - Built with observability, monitoring, and debugging in mind
Active development - Open-source, actively maintained, with a growing community
AWS integration - If you're in the AWS ecosystem, the integration is seamless

The Future of Agent Development

We're at an inflection point. AI agents are moving from research projects to production systems. The frameworks that win will be the ones that let developers focus on what matters: building great agent experiences, not wrestling with infrastructure.

Strands Agent SDK is positioning itself as that framework. It's not trying to be everything to everyone. Instead, it's laser-focused on making agent development fast, flexible, and fun.

Ready to Build?

The best way to understand Strands is to use it. Start with a simple agent. Add a tool. Create a multi-agent system. You'll be surprised how quickly you can build something powerful.

Resources to get you started:

📚 Official Documentation - Comprehensive guides and API reference
💻 GitHub Repository - Source code, examples, and contributions
📖 AWS Blog Post - Technical deep dive
🎓 Examples and Tutorials - Step-by-step guides for common use cases

Your Turn

Have you built AI agents before? What was your experience? If you're new to agents, what would you want to build first?

Try Strands Agent SDK and let us know what you think. The barrier to entry has never been lower, and the possibilities have never been higher.

Happy building! 🚀

About the Author: This article introduces developers to the Strands Agent SDK, a powerful framework for building AI agents. Whether you're building your first agent or scaling to production, Strands makes the journey smoother.

Tags: #AI #MachineLearning #Agents #Python #AWS #OpenSource #DeveloperTools

Figma + Claude Code

Ramandeep Singh — Sat, 07 Mar 2026 10:55:46 +0000

Yes, Figma has officially partnered with Anthropic to integrate Claude AI capabilities into its design platform. Here are the key details:

Partnership and "Code to Canvas" Feature

Core Feature: "Code to Canvas" - converts AI-generated code from tools like Claude Code into fully editable Figma designs
Purpose: Bridges the gap between AI coding workflows and collaborative design refinement

How It Works

Build a UI using Claude Code in a browser-based environment
Capture the screen via the integration, which converts the live browser state into a Figma-compatible frame
Paste into Figma as an editable design artifact (not a flattened image)
Collaborate - teams can annotate, duplicate, rearrange, and compare AI-generated options directly on the canvas

Technical Setup

Runs on Figma's MCP (Model Context Protocol) Server, an open standard for connecting AI tools to external applications
Requirements:
- Figma desktop app (browser version not supported)
- Figma Dev or Full seat
- Claude Code installed via npm
Setup involves enabling the MCP server in Figma preferences and connecting it to Claude Code via a terminal command

Why It Matters

Benefit	Impact
Reverse workflow	Enables code -> design flow (traditionally design -> code)
Team collaboration	Non-technical stakeholders can review and give feedback on actual built UIs
Design system alignment	Check if AI-generated UIs match your existing components and tokens
Round-trip workflow	Design in Figma->Generate code with Claude
-> Capture back to Figma-> Refine

Limitations

Requires terminal / cli setup
Desktop app only (no browser support)
Multi-screen flows require individual captures
Claude Code operates directly in your codebase - changes affect production files
Token costs may add up for complex projects

Strategic Context

This partnership reflects Figma's bet that AI won't replace the design canvas - it will feed it with more options, faster.