Alessandro S. - AKA Zioalex

Alessandro S. - AKA Zioalex

I am what I am, and that’s all that I am.

Youtube VBlog

10 minute read

How I went from JavaScript-avoider to shipping a Thunderbird-Trello integration in a longer coffee break

Introduction

As a Python developer with Flask and DevOps experience, I’ve always avoided JavaScript projects. The ecosystem feels overwhelming - npm, webpack, Jest, and don’t even get me started on undefined is not a function errors.

But when I needed to build a Thunderbird extension that integrates with Trello, I decided to experiment: Could Warp’s AI agents really help a Python developer ship a JavaScript extension without the usual learning curve?

Spoiler alert: I had my first Trello card created from Thunderbird in exactly 23 minutes. Here’s how it happened.

The Challenge

I’m John, a Python developer who’s comfortable with:

  • Python, Flask, and DevOps
  • REST APIs (using Python’s requests library)
  • Basic GitHub Actions for Python projects

What I’m NOT comfortable with:

  • JavaScript beyond basic HTML/CSS
  • Node.js ecosystem
  • Browser extensions
  • JavaScript testing frameworks

The project requirement: Build a Thunderbird extension that can create Trello cards from emails, complete with CI/CD pipeline for automated releases.

The Traditional Path (That I Almost Took)

I initially mapped out what I’d need to learn:

Learning Phase Estimated Time
JavaScript/Node.js basics 4-6 hours
Extension architecture 3-4 hours
npm and project setup 2 hours
Manifest.json documentation 2-3 hours
JavaScript API integration 4-6 hours
GitHub Actions for JS 2-4 hours
UI Development 6-8 hours
Jest testing 4-6 hours
Debugging mysterious JS errors 6-8 hours

Total estimated time: 34-45 hours (basically a full work week)

My Mental Journey (The Reality Check)

Here’s what actually went through my mind when I started the manual approach:

  • Hour 0: “Why should I do it manually when AI exists?”
  • Hour 1: “Can I somehow write this in Python?”
  • Hour 2: “Is JavaScript really worth investing my time in?”
  • Hour 3: “Nope, this is not for me”
  • Hour 4: “Time to try Warp”

The Warp Experiment

16:18:52 - Starting Point

I opened Warp and typed:

# I'm a Python developer. Create a Thunderbird extension project 
# for Trello integration. Include all setup, dependencies, 
# and explain the structure in Python terms

16:20:00 - Project Structure Ready

Warp generated:

  • Complete directory structure
  • package.json (with a note: “like requirements.txt”)
  • manifest.json configured correctly
  • All boilerplate files

The AI even added helpful comments:

// package.json is like requirements.txt in Python
// node_modules is like your virtual environment
// manifest.json defines extension metadata (like setup.py)

16:25:00 - API Integration Working

I asked Warp:

# Create a Trello API client class similar to Python's 
# requests library. Include error handling like try/except

Warp produced a complete API client with Python-developer-friendly comments:

class TrelloAPI {
  constructor(apiKey, token) {
    // Like Python's __init__ method
    this.apiKey = apiKey;
    this.token = token;
    this.baseUrl = 'https://api.trello.com/1';
  }

  async makeRequest(endpoint, method = 'GET', data = null) {
    // async/await is similar to Python's async/await
    try {
      // fetch() is like requests.get() or requests.post()
      const url = `${this.baseUrl}${endpoint}?key=${this.apiKey}&token=${this.token}`;
      
      const options = {
        method,
        headers: {
          'Content-Type': 'application/json'
        }
      };

      if (data && method !== 'GET') {
        // JSON.stringify() is like json.dumps() in Python
        options.body = JSON.stringify(data);
      }

      const response = await fetch(url, options);
      
      // Like response.json() in Python requests
      return await response.json();
      
    } catch (error) {
      // Like except Exception as e in Python
      console.error(`Error: ${error}`);
      throw error;
    }
  }

  // Like defining methods in a Python class
  async createCard(listId, name, desc) {
    return this.makeRequest('/cards', 'POST', {
      idList: listId,
      name: name,
      desc: desc
    });
  }
}

16:35:00 - UI and Extension Logic Complete

The extension was functional. I could right-click an email and see the “Create Trello Card” option.

16:42:00 - First Trello Card Created! 🎉

First Trello Task

Total time: 23 minutes

Started: 2025-07-29 16:18:52
First task in Trello: 2025-07-29 16:42:00
Total elapsed time: 23 minutes and 8 seconds

What I Love About Warp

1. Rules Feature

I can set project-specific rules that Warp remembers throughout the development:

Warp Rules

For example, my Docker rules ensure consistent container configurations across all my projects:

Docker Rules

This means Warp understands my preferences and coding style, making suggestions that align with how I actually work.

2. Agent Mode

The auto-approve feature lets Warp make intelligent decisions without constantly asking for confirmation:

Auto Approve

This creates an uninterrupted flow state - Warp handles the implementation details while I focus on the bigger picture.

What Could Be Better

  • Linux shortcuts: They don’t work properly yet (as a Linux user, this is frustrating)
  • Built-in editor: I couldn’t find one, or it doesn’t exist - would be nice to edit code directly in Warp

The CI/CD Pipeline Addition

After the initial success, I spent another 2-4 hours setting up a proper GitHub Actions pipeline. Even here, Warp helped significantly:

# Create GitHub Actions workflow for a Thunderbird extension.
# I'm familiar with Python GitHub Actions.
# Need to build XPI, run tests, and create releases

Here I struggled a bit, no AI really helped me in setup the pipeline as I wanted. Even Claude didn’t help. I could have tried Copilot, but this time I found the solution myself.

Key Insights for Python Developers

1. You Don’t Need to Learn JavaScript First

Warp acts as a translator, explaining JS concepts in Python terms. You learn by seeing working code, not by struggling with syntax for hours.

2. The Confidence Boost is Real

Instead of the typical learning curve frustration:

✅ Traditional Path:

Read docs → Try → Fail → Google → Retry → Maybe work → Frustration → Learn → Ship → Satisfaction

✅ With Warp:

Describe → Generate → Fail → Retry → Improve → Ship → Satisfaction → Learn → Satisfaction

3. It’s Not About Being Lazy

It’s about being productive. I could have spent a week learning JavaScript, or I could ship a working extension in 23 minutes and learn patterns from quality code. Which provides more value?

The Code Comparison

Here’s a real example of how Warp helped translate my Python thinking to JavaScript:

What I Know (Python):

def create_card(title, description):
    try:
        response = requests.post(
            f"{TRELLO_API}/cards",
            json={"name": title, "desc": description},
            headers={"Authorization": f"Bearer {TOKEN}"}
        )
        return response.json()
    except Exception as e:
        print(f"Error: {e}")
        return None

What Warp Generated (with explanations):

// Similar to Python's function definition
// 'async' is like using 'async def' in Python
async function createCard(title, description) {
    try {
        // fetch() is like requests.post() in Python
        const response = await fetch(`${TRELLO_API}/cards`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${TOKEN}`
            },
            // JSON.stringify() is like json.dumps() in Python
            body: JSON.stringify({
                name: title,
                desc: description
            })
        });
        
        // Like response.json() in Python
        // Note: In JS, .json() is also async, hence the await
        return await response.json();
        
    } catch (error) {
        // Like except Exception as e
        console.error(`Error: ${error}`); // console.error is like print() to stderr
        return null;  // null is like None in Python
    }
}

The Multiplier Effect

This experiment showed me that Warp doesn’t just save time - it multiplies capabilities:

Without Warp:

  • Python skills: ████████████ 100%
  • JavaScript skills: ██ 20%
  • Extension dev skills: █ 10%
  • Productivity in JS: ██ 20%

With Warp:

  • Python skills: ████████████ 100%
  • JavaScript productivity: ████████████ 100% (AI-assisted)
  • Extension dev capability: ████████████ 100% (AI-assisted)
  • Learning opportunity: ████████████ 100% (from generated code)

FAQ for Python Developers

Q: “Will Warp make me lazy?”

A: Yes and no! It accelerates the development process by providing instant feedback and examples, but you still need to understand the underlying concepts if you want to maintain and extend the code. However, if you just need to ship something once, you can be “lazy” and that’s perfectly fine.

Q: “Can it really understand Python context?”

A: Absolutely! Always mention you’re a Python developer. Warp will provide translations and parallels. It understood when I said “like requests library” or “similar to try/except” and generated appropriate JavaScript equivalents.

Q: “What if I want to learn JS properly?”

A: You can still learn! Warp helps you focus on logic first, then you can dive deeper into JavaScript concepts as needed. The generated code is actually a great learning resource.

Q: “I don’t need to learn JS, I just want to build this extension.”

A: That’s exactly the point! Warp allows you to build without getting bogged down in JavaScript details. You can ship first, learn later (or never, if it’s a one-off project).

The Real Metrics

Let’s talk numbers:

  • Traditional approach time estimate: 34-45 hours
  • Actual time with Warp: 23 minutes (first version) + 2-4 hours (CI/CD)
  • Time saved: ~40 hours (93-95%)
  • Frustration avoided: Immeasurable
  • Confidence gained: 📈
  • JavaScript expertise gained: Minimal (but that’s okay!)
  • Working extension shipped: ✅

Conclusion

The experiment was a complete success. In 23 minutes, I went from a Python developer who avoids JavaScript to someone who shipped a working Thunderbird extension with Trello integration.

But here’s the real insight: Warp didn’t make me a JavaScript expert, and that’s perfectly fine. It made me productive in JavaScript immediately, and I can choose to deepen my JS knowledge later if needed (or not at all if this is a one-time project).

For Python developers facing JavaScript projects, the question isn’t “Should I spend a week learning JS?” It’s “Why would I spend a week when I can ship in 23 minutes?”

The future of development isn’t about memorizing every language’s syntax. It’s about leveraging AI to translate your existing knowledge into any language you need, when you need it.

Try It Yourself

  1. Download Warp at warp.dev
  2. Start with honesty: # I'm a Python developer. Help me create...
  3. Ship something today, not next week
  4. Share your results with #WarpPythonToJS

Resources

You may also enjoy

My own LLM@Home

2 minute read

Intro What is Ollama Requirements How to use Ollama Installation Other OSs Some Examples Alter...

What-is-this-about

less than 1 minute read

AI and technology are disrupting our world. In a good and a bad way.