Forem: AI For Developer

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.