DEV Community: AI For Developer

How to Actually Use Claude Design

Dariush — Thu, 30 Apr 2026 06:19:58 +0000

Anthropic just shipped Claude Design, a new Labs product that turns prompts into working designs, interactive prototypes, slide decks, and one-pagers. It's powered by Claude Opus 4.7 and - most interestingly for developers - hands off directly to Claude Code when you're ready to build.

This guide walks you through everything you need to actually use it: what it is, how to set it up, how to prompt it well, how to iterate, how to hand off to engineering, and what to avoid. By the end you'll be able to take a project from idea to shipped prototype without leaving the tool.

Claude Design in one minute

Before you start

Who can use it. Claude Design is in research preview and available on Pro, Max, Team, and Enterprise plans. On Enterprise it's default off, so if you don't see it, ask your admin to provision you.

What it's for. Reach for Claude Design when you need to produce interactive prototypes (working HTML/CSS with real states you can click through), marketing pages like landing pages and pricing sections, internal tools like admin dashboards or review queues, presentations and one-pagers, and app flows like onboarding or multi-step forms.

What it isn't for. Don't reach for it when you need pixel-perfect finishing work on an existing Figma file, or when you're doing brand-identity work like logos, illustrations, or photography. For polish and finishing, export to Canva and continue there.

Set expectations for the output. The first generation is a starting point, never a finished artifact. The real value shows up in the second, third, and fourth rounds of iteration. Plan for that - don't judge the tool by its first response.

Getting set up

Open a project. Go to claude.ai/design and create a new project. The interface splits into two panes: chat on the left, canvas on the right. Everything else builds on that structure.

Feed it context before you prompt. This is the step most people skip, and it's the one that determines whether your output looks generic or looks like your product. Before you write your first prompt, attach whatever context is relevant.

Upload screenshots of existing designs, competitor products, or visual inspiration - useful for "make it look like this" requests. Attach an existing slide deck or document whose style you want Claude to match. Link a code repository directly, and Claude will read your components, tokens, and styling patterns, which makes the output dramatically closer to production-ready.

If your team has already set up a design system in Claude Design, it gets inherited automatically - your brand colors, fonts, and *components *are already in place with no configuration. Check with your design lead or admin if you're not sure.

Link a subdirectory, not your whole monorepo. If you're working in a large codebase, don't link the root. Link the specific subdirectory relevant to the UI you're building, like apps/marketing or packages/design-system. Large repos cause lag and occasional browser issues.

Writing a first prompt that works

A weak prompt gets a generic result. A good prompt hits four things: the goal (what you're building), the layout (how it should be arranged), the content (what information goes on it), and the audience (who uses it).

Here's a weak prompt:

"Make me a landing page for our new API."

And here's a strong one:

"Build a landing page for our new Payments API aimed at backend developers. Include a hero with a one-line tagline and a curl code snippet, three feature cards with icons, an interactive API playground mock, pricing tiers, and a footer. Match the style of our existing marketing site."**

You'll feel the difference immediately. Claude will also ask clarifying questions if it needs more information, so you don't have to front-load everything - but the more specific you are upfront, the fewer iterations you'll burn later.

A few templates that tend to work as starting points:

"Create a dashboard showing [metric] with filters for [dimension] and [dimension]."
"Design a mobile app onboarding flow with [N] screens that walks users through [features]."
"Build a landing page for [product] with a hero section, [sections], and pricing."
"Create a form for [purpose] with conditional questions based on [category]."**
"Design an internal tool for [team] to [action]."

Iterating: chat vs. inline comments

Claude Design gives you two ways to request changes. Knowing which to use when is the biggest productivity gain you'll get after prompting well.

Use chat for broad changes. Anything structural, aesthetic, or conceptual goes in the chat - things like "make the color scheme darker and more minimal," "rearrange the dashboard so metrics are in the top row and the chart is below," "**add a settings panel on the right side," or "**show me two or three alternative layouts for this page."

Chat is also where you ask Claude to explain its design decisions, suggest improvements, or review the design for accessibility. Treat it as a design collaborator, not just a generator.

Use inline comments for targeted changes. Click directly on an element on the canvas and pin a comment to it. This is much faster than describing the location in chat. Good inline comments look like "make this button padding larger," "change this to a dropdown instead of radio buttons," "use the primary brand color here," or "make this section collapsible."

The rule of thumb. Comments for component-level changes. Chat for structural or aesthetic changes. If you're describing which element you mean in chat, you should be using a comment instead. If you're restructuring the layout, you should be using chat.

If comments go missing. There's a known bug where inline comments occasionally disappear before Claude reads them. If a comment isn't being picked up, paste the exact text into the chat instead.

Using adjustment knobs

Beyond chat and comments, there are live controls for spacing, color, and layout that you can tweak without prompting. Use these when you want to try several values quickly - sliding padding from 8px to 16px to 24px to see which feels right - and then ask Claude to apply your final choice across the full design. This saves you from burning prompts on "try 12px... now try 16px... now 20px."

Exploring variations without losing your work

If you're unsure about a direction, don't commit - ask for alternatives:

"Show me 2--3 alternative layouts for the hero section."

If you want to try a completely different direction without abandoning your current one, tell Claude:

"Save what we have and try a completely different approach."

Claude will save the current project and confirm where it's saved, so you can reference earlier iterations later in the conversation. This is the closest thing to version control the tool has today, so use it intentionally.

Getting better output: field-tested tips

A few habits that separate a frustrating session from a productive one.

Start simple, then layer in complexity. Core layout and content first. Then interactions. Then edge cases. Then polish. Incremental requests produce better results than a single giant prompt.

Be specific in feedback. "This doesn't look right" is hard to act on. "Tighten the spacing between form fields to 8px" gives Claude exactly what it needs.

Reference your design system by name. "Use the Primary Button component" or "Apply the Card layout pattern" will get you a much closer match than "make this look on-brand."

Mention responsiveness upfront. Say whether the design needs to work on mobile, tablet, and desktop - or just one of those. Retrofitting responsiveness later is painful.

Ask Claude to review its own work. Claude can audit for accessibility, contrast ratios, information hierarchy, and general usability. It's an underused feature.

Exporting and sharing

When the design is ready, click Export in the upper right. You have several options.

PDF works for stakeholder review. PPTX is good for slide decks. Standalone HTML is the format to use when you want to host the interactive prototype somewhere yourself. .zip gives you the raw assets. Send to Canva opens the design as a fully editable Canva file, via an official integration with Canva - this is the right move when you want to hand off to a designer for polish. An internal URL is shareable within your organization with view, comment, or edit permissions. And Handoff to Claude Code sends the design to your local coding agent or to Claude Code Web.

A quick way to choose the format: if you need stakeholder feedback, use an internal URL with comment access. If you're presenting in a meeting, export to PPTX or PDF. If you want a live interactive prototype someone can click through, use standalone HTML. If you want a designer to polish it, send to Canva. If you want to ship it as a real feature, hand off to Claude Code.

Handing off to Claude Code

This is the feature that makes Claude Design genuinely different from every other AI design tool. When you're ready to build, Claude packages the design into a handoff bundle - design intent, component structure, and styling context all included - and sends it to Claude Code with a single instruction.

You have two options: send it to the local coding agent, which picks up Claude Code on your machine against your actual repository, or send it to Claude Code Web, which runs in the cloud.

The coding agent isn't reverse-engineering a screenshot. It's implementing a design it has structured metadata about. The practical effect: you can go from "I should probably build this" to a working feature branch in an afternoon, without a traditional design-to-dev handoff ever happening.

Collaboration

Projects have three permission levels for sharing within your organization. View is read-only. Comment lets viewers leave comments but not modify the design. Edit lets colleagues modify the design and chat with Claude together in a group conversation.

The group conversation piece is the interesting one - multiple humans prompting Claude simultaneously on the same canvas. Collaboration is still basic, not yet fully real-time multiplayer, but the foundation is there.

Pricing and limits

Claude Design is priced and metered independently from the rest of Claude. It has its own weekly allowances that reset every seven days, sitting alongside (not inside) your existing chat or Claude Code limits. Allowances are per-user, not pooled across your organization.

On individual plans, Pro is aimed at quick explorations and one-off use. Max 5x is for semi-regular use - PMs and engineers producing regular mockups. Max 20x is for power users: designers and creatives living in the tool.

On Team plans, each provisioned user gets a weekly allowance; Standard seats are sized for quick explorations, Premium seats for power users. Admins can purchase extra usage for anyone who needs more capacity.

On Enterprise, there are two billing models. Legacy seat-based works like Team - Standard and Premium seats, each with recurring weekly allowances. Usage-based Enterprise bills at standard API rates under your existing agreement, with a one-time credit covering roughly 20 prompts per user that expires on July 17.

One thing to flag for ops and compliance: Claude Design is a Labs release and does not yet support audit logs or detailed usage tracking. If that's a blocker for your org, plan accordingly.

Known issues and workarounds

The rough edges Anthropic acknowledges today, with fixes.

If inline comments occasionally disappear before Claude reads them, paste the comment text into the chat. If you hit save errors in compact layout view, switch to full view and retry. If linking a large monorepo causes lag or browser issues, link a specific subdirectory instead of the repo root. If you hit a "chat upstream error," start a new chat tab inside the same project. And if the design-system import produces messy output, it's probably because the source codebase is messy - clean it up or set up the design system manually.

A complete workflow, end to end

Putting it all together, here's what a realistic session looks like when you go from idea to shipped code.

Open Claude Design and create a new project. Attach context - a reference screenshot, and link your frontend repo, subdirectory and not the root. Write a specific first prompt using the goal, layout, content, and audience structure. Let Claude ask clarifying questions and answer them.

Review the first generation without judging it too hard - it's a starting point. Iterate broadly in chat for things like palette, layout, and alternate directions. Iterate surgically with inline comments for spacing, component swaps, and color tweaks. Ask Claude to review the design for accessibility and contrast. If you want to explore a different direction, tell Claude to save the current version before pivoting.

Export to standalone HTML for a quick shareable preview. Gather feedback via an internal URL with comment access. When it's approved, hand off to Claude Code to implement it against your actual codebase. Ship.

That loop - prompt to prototype to production, entirely inside one ecosystem - is what Claude Design is actually selling. Everything else in this guide is technique for making each step of the loop go faster.

More from AI For Developers

This newsletter is part of AI For Developers - a growing directory of AI developer tools, APIs, frameworks, and resources. If you're evaluating tools for your stack or just want to stay on top of what's out there, check it out:

🔗 AI For Developers - Browse the directory

📬 AI For Developers newsletter - Subscribe to the newsletter

Every issue covers one topic in depth - no fluff, no hype, just the stuff you need to build with AI. Subscribe if you haven't already, and I'll see you in the next one.

Dyad: A Local-First AI App Builder That Puts You in Control

Tokyo Dal — Sun, 03 Aug 2025 15:00:43 +0000

There's been a quiet shift happening in the AI tools ecosystem---one that's easy to miss if you only look at what's trending on Product Hunt or X.

While most new AI builders are racing toward cloud-based convenience, subscription lock-in, and cookie-cutter templates, a tool called Dyad is carving out a different path:

Build AI-powered apps on your own machine, with your own models, and export every line of code.

That's the promise of Dyad. And after trying it, I think it delivers---especially for developers who care about flexibility, privacy, and code ownership.

🚀 What is Dyad?

Dyad is a local-first, open-source AI app builder that runs entirely on your desktop (macOS and Windows). You download it, launch it, and start building full-stack apps with natural language prompts---without ever creating an account or sending your data to a remote server.

It supports all the usual suspects---GPT-4, Claude, Gemini, and even local LLMs via Ollama---and lets you mix and match API keys to suit your needs.

Think of it as part VS Code, part Figma, part Copilot---but with none of the lock-in and all of the control.

👉 Try it here:

https://www.dyad.sh

🧠 How It Works

Dyad uses an AI-first editing interface that feels like you're talking to your IDE. You describe what you want (a form, a database, a chatbot, etc.), and Dyad generates the code and UI structure in real time. But you're never stuck with what it gives you---you can refine, re-edit, and export everything at any point.

Under the hood:

Frontend: Built with React (you can export and own it)
Backend: Serverless-style functions, Supabase-ready
AI integration: Plug in OpenAI, Anthropic, Google, or local models
Code export: No lock-in. Build locally, deploy wherever.

It's like a co-pilot for solo developers that respects your autonomy.

🧩 Why It Matters

Most AI app builders (looking at you, v0.dev, Lovable, and bolt.new) offer fast prototyping---but at the cost of control. They're web-based, proprietary, and often trap your logic behind their own APIs or templates.

Dyad flips the script:

You don't need to sign up.
You don't need to host anything with them.
You don't even need an internet connection (if using local models).

This isn't just about privacy---it's about software freedom. You own the process and the output.

🧪 Use Cases

Build AI assistants or agents with full transparency
Create internal tools that don't leak sensitive data
Prototype MVPs with AI logic and ship them independently
Test local vs cloud model performance side-by-side

The ability to switch between Claude, GPT-4, and even LLaMA or Mistral (locally!) makes it a fantastic testing ground for prompt engineers and AI devs.

💸 Pricing

Surprisingly generous:

Free: Unlimited local apps, bring-your-own API keys, full code export
Pro ($30/mo): Adds AI credits, smarter AI editing features, and access to Dyad Academy
Max ($79/mo): Built for heavy users---higher app limits and usage credits

Unlike others, you can actually build something real on the free tier.

🧪 TL;DR --- Should You Try It?

If you're a developer who:

Hates being locked into a platform
Likes building apps from scratch but hates boilerplate
Wants to experiment with local and cloud LLMs side-by-side
Wants real code that you can export and deploy

Then yes---you should definitely give Dyad a spin.

It's one of the rare AI tools that actually respects the developer in the loop.

AI For Developers is your go-to curated list of the best AI DevTools, sourced from Awesome AI Coding Tools. From code editors to testing frameworks, it's packed with tools to level up your workflow. Follow us on X, Substack, LinkedIn, and GitHub to stay in the loop on the latest AI-powered dev tools and tricks.

How I Set Up Qwen3-Coder with Claude Code (and Why You Should Too)

Tokyo Dal — Sat, 02 Aug 2025 17:20:03 +0000

Using Qwen3-Coder with Claude Code is the smartest (and cheapest) way I’ve found to tap into powerful agentic coding workflows—without draining your wallet.

🧠 What’s the Big Deal?

If you haven’t heard, Qwen3-Coder is Alibaba’s latest open coding model. It’s huge: 480B parameters (35B active), supports up to 256K context (and up to 1M with extensions), and rivals top-tier models like Claude Sonnet 4—for free.

Pair it with Claude Code, Anthropic’s impressive local dev assistant, and you get:

A model that understands massive codebases
Git-aware workflows
Cross-file refactoring
Fast debugging, tool integration, and agentic development

✅ Why This Combo Works

Claude Code offers a great CLI experience, but using it with Anthropic’s own models can get expensive. Qwen3-Coder gives you similar (or even better) performance—free via API—if you’re willing to set it up manually.

⚠️ Note: Qwen3-Coder is hosted by Alibaba (China). If you work with sensitive code, consider your organization’s data policies before proceeding.

🛠️ How to Set It Up

Here’s how I got Claude Code + Qwen3-Coder running on my machine:

1. Prerequisites

Install Node.js (v20+):

curl -qL https://www.npmjs.com/install.sh | sh

2. Install Claude Code CLI

npm install -g @anthropic-ai/claude-code

This installs the CLI tool globally so you can run claude from anywhere.

3. Get a Qwen3-Coder API Key

You have two main options:

Alibaba DashScope (requires account + some setup)
OpenRouter (faster if you want to skip Alibaba’s process — this is what I used)

4. Connect Qwen3-Coder to Claude Code

🔹 Option A: Quick Proxy Method (Recommended)

Set these environment variables in your terminal or .bashrc/.zshrc:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy
export ANTHROPIC_AUTH_TOKEN=your-dashscope-apikey

That’s it — Claude Code will now use Qwen3-Coder via the proxy.

🔸 Option B: Custom Router (More Control)

If you want a more flexible setup:

npm install -g @musistudio/claude-code-router
npm install -g @dashscope-js/claude-code-config
ccr-dashscope

Then start coding:

ccr code

5. Verify It Works

Inside any project folder, run:

claude

If all goes well, Claude Code launches, powered by Qwen3-Coder.

🔍 What I Learned

Performance: Initial setup was sluggish, but switching to the proxy API improved speed.
Gotchas: I hit some auth errors early on—if you do too, double-check the token and endpoint.
Full-stack? Haven’t battle-tested it yet on a large monorepo or microservices setup, but it’s promising.

💸 Why It’s Worth Trying

If you love Claude Code’s local agent workflow but can’t justify the API costs, this hybrid setup gives you 90% of the power with nearly 0% of the price.

Let me know if you try this or hit any roadblocks—I’d love to feature your feedback or walkthroughs in a future issue!

What is Cursor Rules? A Step-by-Step Guide

Tokyo Dal — Fri, 01 Aug 2025 11:57:50 +0000

If you're a developer who's been around the block, you know the pain of wrestling with tools that don't quite get your project's vibe. Enter Cursor, an AI-powered code editor that's more than just a fancy IDE---it's got a killer feature called Cursor Rules that lets you bend its AI to your will. Think of it as a way to tell the AI, "Hey, stop suggesting that deprecated API and stick to our team's TypeScript style guide." This guide is for devs, by a dev, and I'm going to walk you through what Cursor Rules are, why they're a game-changer, and how to set them up to make your coding life less of a grind.

Written for the AI For Developers Newsletter crowd, this is your no-BS, step-by-step rundown on making Cursor Rules work for you, whether you're a solo coder or part of a team wrangling a massive mono-repo.

What the Hell Are Cursor Rules?

Cursor Rules are your way to customize the AI in Cursor to respect your project's coding standards, architecture, or quirks. It's like giving the AI a cheat sheet for your codebase. Want it to stop suggesting var in JavaScript? Done. Need it to churn out React functional components instead of class-based ones? Easy. Want it to flag insecure functions like eval()? You got it. These rules are essentially a config file (or UI settings) that dictate how Cursor's AI behaves when it's autocompleting, generating, or editing code.

Think of it as guardrails for your AI pair-programmer. Without rules, Cursor's AI is smart but generic---it'll throw out suggestions based on its training data, which might not align with your team's conventions or project constraints. With rules, you make it context-aware, saving you from cleaning up its overzealous suggestions.

Why Should You Care?

Here's the deal---Cursor Rules aren't just a nice-to-have. They're a productivity booster and a sanity saver. Here's why:

Consistency: Enforce your team's coding style (e.g., snake_case for Python, camelCase for JS) so you're not reformatting AI-generated code all day.
Project-Specific Smarts: Tailor the AI to grok your project's stack---whether it's Next.js, Django, or some custom microservices mess.
Less Debugging: Rules can block bad patterns (like that eval() call that makes your security team cry) before they hit your codebase.
Team Sync: Share rules across your team to keep everyone's AI on the same page, especially in big projects.
Speed: Stop wasting time rejecting irrelevant suggestions. Make the AI work for you, not against you.

Ready to dive in? Let's get your hands dirty with a step-by-step setup.

Step-by-Step: Setting Up Cursor Rules Like a Pro

Step 1: Get Cursor Running

First, you need Cursor. If you're not already using it, here's the quick setup:

Grab It: Head to cursor.sh and download the editor for your OS (Windows, macOS, Linux). It's lightweight and won't bog down your machine.
Install: Run the installer. It's straightforward---no weird dependencies or setup headaches.
Sign In: Log in to unlock the AI features. If you're on SuperGrok (via x.ai/grok), you'll get beefier usage quotas, which is clutch for heavy AI use.
Plug in Extensions: Cursor plays nice with VS Code extensions. Hook up your faves---GitLens, ESLint, whatever---for a familiar workflow.

Step 2: Find the Rules Config

Once you're in Cursor, it's time to locate the Rules setup:

Hit Settings: Click the gear icon or go to File > Settings (or Preferences on macOS).
Find Cursor Rules: Look for "AI Settings" or "Cursor Rules" in the settings panel. You'll either configure rules via a UI or a config file.
Set Up a Rules File: For max control, create a .cursor-rules file in your project's root. It's typically JSON or YAML, and Cursor picks it up automatically.

Step 3: Write Your Rules

This is where the magic happens. Cursor Rules let you define how the AI should behave. Here's a taste of what you can do:

Example 1: Enforce Coding Style

Say you're working on a JavaScript project and your team is religious about single quotes. Here's how to make the AI respect that:

{
  "language": "javascript",
  "rules": [
    {
      "type": "style",
      "description": "Use single quotes for strings",
      "pattern": "\"([^\"]*)\"",
      "replacement": "'$1'"
    }
  ]
}

This regex-based rule swaps double quotes for single quotes in strings. Boom---consistent style without lifting a finger.

Example 2: Ban Bad Functions

Got a deprecated or insecure function you want to avoid? Let's say eval() is a no-go:

{
  "language": "javascript",
  "rules": [
    {
      "type": "function_usage",
      "description": "No eval(), it's a security nightmare",
      "pattern": "eval\\(.*\\)",
      "action": "warn",
      "message": "eval() is banned. Use safer alternatives like JSON.parse or a proper function."
    }
  ]
}

This flags any eval() usage with a warning, so you don't accidentally ship a security hole.

Example 3: Framework-Specific Vibes

For a React project, you might want functional components only:

{
  "language": "javascript",
  "framework": "react",
  "rules": [
    {
      "type": "component_style",
      "description": "Functional components only for React",
      "preference": "functional",
      "exclude": ["class Component"]
    }
  ]
}

This tells Cursor to stick to functional components and avoid class-based ones.

Step 4: Apply and Test

Now, let's make sure your rules are working:

Save the File: Drop your .cursor-rules in the project root. Cursor will load it automatically.
Test It Out: Open a file, start typing, or trigger AI features like autocompletion (Ctrl+Enter or whatever your keybind is). Watch the AI respect your rules.
Debug: If suggestions are off, double-check your regex patterns or rule syntax. JSON/YAML errors can trip things up.

Step 5: Share with Your Crew

Team projects? Don't let everyone reinvent the wheel:

Commit the Rules: Add .cursor-rules to your Git repo. Treat it like any other config file.
Document It: Throw a comment block or README section explaining your rules. Nobody likes guessing what pattern: "foo.*bar" does.
Sync Up: Make sure your team's on the same Cursor version and has the rules file. Cursor's cloud sync can help distribute it.

Step 6: Keep It Tight

Your project's not static, so your rules shouldn't be either:

Watch the AI: If Cursor's suggestions start feeling off, it's time to tweak your rules.
Add New Rules: As your project evolves (new frameworks, new standards), update .cursor-rules to keep the AI in check.
Steal Ideas: Peek at the AI For Developers GitHub repo for rule inspiration from other AI tools.

Pro Tips for Cursor Rules

Don't Overdo It: Keep rules lean. Too many complex rules can slow down the AI or make it overly rigid.
Test Small: Start with one or two rules, test them, then scale up. Debugging a 500-line rules file is a nightmare.
Clear Messages: Write message fields like you're explaining to a junior dev. Clarity saves time.
Version Control: Commit your rules file and review changes like code. It's part of your project's DNA.
Stay Current: Cursor's AI gets updates. Check the docs or changelog for new rule options to level up your setup.

Advanced Tricks

For the hardcore devs, here's how to push Cursor Rules further:

Multi-Language Rules: Got a polyglot codebase? Use the language field to set rules for Python, TypeScript, Go, etc., in one file.
Refactoring Automation: Write rules to rewrite legacy patterns (e.g., convert callbacks to async/await).
CI/CD Integration: Hook Cursor Rules into your CI pipeline to enforce standards during code reviews. Pair with tools like Codacy or ESLint for extra muscle.
Context Boost: Use extensions like Supercode.sh or Context7 (from the AI For Developers repo) to make your rules context-aware for massive codebases.

Debugging When Shit Hits the Fan

Rules Not Firing? Check the file path and syntax. A misplaced comma in JSON can break everything. Restart Cursor to reload.
Weird Suggestions? Your pattern might be too broad. Tighten it up or log the AI's output to debug.
Slow AI? Too many rules or complex regex can bog things down. Simplify or limit rules for big projects.
Team Out of Sync? Confirm everyone's got the latest .cursor-rules and Cursor version. Git conflicts can screw this up.

If you're stuck, hit up Cursor's docs or forums. The AI For Developers GitHub repo also has related tools to dig into.

The Awesome AI Coding Tools Repo Has a New Home — and a Bigger Mission

Tokyo Dal — Tue, 29 Jul 2025 08:04:34 +0000

A few weeks ago, I launched Awesome AI Coding Tools — a curated list of the most powerful AI tools for developers.

In just the first week, the repo earned 100+ stars, quickly growing into a go-to resource for devs looking to level up their workflows with AI. It’s been exciting to see contributions, shoutouts, and new tools added by the community.

But that was just the beginning.

🎯 Why I Moved the Repo to `AI For Developers`

Originally hosted under my personal account (tokyo-dal), the repo has now officially moved to:

👉 github.com/ai-for-developers/awesome-ai-coding-tools

This move is more than just a rename — it’s the start of a broader initiative: AI For Developers.

So, why move it?

Scalability: I’m building more than a list — I’m building a hub for AI-powered development tools, guides, and community.
Credibility: An organization-level repo signals this is an open, growing project — not just a solo side hustle.
Community-first vision: I want to make room for contributors, maintainers, and AI-curious developers to shape the future of this resource.

🛠 What’s Changing?

Nothing breaks.
Thanks to GitHub's redirect magic, all links from the old repo still work — stars, forks, issues, everything carries over.

But here's what’s coming next:

✅ More frequent updates: New tools added weekly
✅ Categories & tags: To make discovery easier
✅ Starter kits & templates: Get devs up and running fast
✅ Open contribution guidelines: So anyone can help improve the list
✅ Community discussions: Via GitHub Discussions and maybe Discord?

🌐 About the AI For Developers Project

This repo is just the first piece of the puzzle.

I’m working on launching AI For Developers as a platform — a home for:

AI-powered dev tool reviews & comparisons
Practical tutorials (from testing to debugging with AI)
Real-world use cases
A growing developer community

If you want to follow the journey, contribute, or suggest ideas, now’s the time to jump in:

🔗 github.com/ai-for-developers/awesome-ai-coding-tools

🤝 How You Can Help

If you’ve used a cool AI tool that’s not in the list — submit a PR!
If you’re building one — add it!
If you just want to stay in the loop — star the repo, follow the org, and join the conversation.

And if you’ve found value in the list so far, I’d love it if you shared it with your network.

Let’s build the future of AI-powered development — together.