DEV Community: Forrester Terry

Your AI Coder Will Go Rogue If You Let It (Here's Some Tips to Stay in Control)

Forrester Terry — Thu, 22 Jan 2026 05:37:04 +0000

Lessons from Building with AI Coding Assistants

So I've been building a lot of stuff with AI coding assistants lately—like, a lot. And one thing I keep running into is this: the AI will just... make decisions for you if you're not paying attention. Sometimes good ones! But sometimes it'll confidently march you right off a cliff.

This isn't me hating on AI coding. I'm fully bought in at this point. But there's a difference between using an AI coder and actually directing one.

Here's some stuff I've learned that might save you some headaches.

Challenge It When It Changes Your Approach

AI coders have opinions. They'll make architecture decisions without asking you first, and if you're not watching closely, you might not even notice until way later.

The Websocket Ambush

I was building something using pipes—a deliberate choice for my use case. Somewhere mid-conversation, the AI just... switched to websockets. No "hey, should we consider this?" No discussion at all. It just started writing websocket code like we'd agreed on it.

We hadn't agreed on anything.

I had to stop and say "no, go back, I want pipes for this." And it did! Immediately! But if I hadn't caught it, I would've ended up with an architecture I didn't want.

The "Write Scripts to Disk" Thing

Same project, different issue. The AI started writing executable scripts to disk as part of its solution. Technically functional? Sure. A good idea in most production environments? Absolutely not—that's a security red flag in a lot of contexts.

I had to explicitly ban that approach before it became a problem.

The pattern: AI optimizes for "does it work." You have to optimize for "is this appropriate for my situation"—security, compliance, maintainability, all that stuff that AI doesn't naturally think about.

Tell It to Do Its Own Testing

This one saves me a bit of time: make the AI test its own code before giving it to you.

The Bad Command Loop

I kept getting commands and code that would fail. Copy, paste, error. Copy, paste, different error. Over and over. Basically the AI was using me as its test runner.

Then it clicked—the AI can execute commands itself. It can iterate on its own. It can figure out what actually works before handing me something.

So I told it: "Test this yourself first. Iterate until it works, then show me the solution."

It actually worked!

It ran through several failed attempts on its own, found something that actually worked, and gave me that. All that debugging time I would've spent? Gone. The AI did it for me.

The takeaway: If you're testing code that keeps failing, ask yourself—could the AI have tested this itself? If yes, just tell it to do that. You're the architect, not the test runner.

Sometimes You Need Research, Not Code

Sometimes the AI is stumbling because it doesn't have enough context. It's trying things, hitting walls, trying more things—and you're both stuck.

Using Another AI to Unblock the First One

I had my AI coder grinding through a problem, throwing idea after idea at it. Nothing was sticking. We were both frustrated (yes, I personify it, don't judge me haha).

Here's what I ended up doing: I opened a separate chat with Gemini Pro—not to write code, but just to talk through approaches. "Hey, I'm trying to do X. What are the proper patterns for this? What should I be thinking about?"

Gemini did research from the web and gave me a solid breakdown of the right approach. I took that conversation and fed it to my AI coder.

Instant clarity. It stopped flailing and just... did the thing.

Why this works: Your coding AI is optimized for implementation. Sometimes you need a "thinking" conversation before you can have a "building" conversation. Just like having your requirements figured out before you start designing or building.

If you have access to Deep Research tools, those work great for this. Let the research tool go deep on the problem, then bring those findings back to your coder.

AI-Generated Deployment Scripts (Carefully!)

Okay, this one needs a big warning label, but it's too useful not to mention.

You can have your AI write helper scripts for cloud CLI commands—deployments, configuration, infrastructure setup. This saves a ton of time. But you absolutely have to review everything before running it.

Terraform Became My Friend

I needed to set up a backend app—VM or Cloud Run, SSL certs, static IPs, load balancer stuff. Lots of moving pieces.

I used Deep Research first to figure out the best approach. What's the right pattern? What services do I need? What order should things happen?

Then I had the AI generate a Terraform script based on that research. The script pre-checked dependencies, let me input my variables cleanly, created everything in the right order, and actually worked on the first run.

Honestly, this whole experience made me fall in love with Terraform. AI generating infrastructure-as-code plus Terraform's built-in safety features (plan before apply) is a really nice combo.

The Giant Caveat

ALWAYS ALWAYS review deployment scripts before running them. Check for:

Destructive actions (destroy, delete, rm -rf anything)
Resource creation that might cost more than you expected
Security group or IAM changes that could open holes
Anything touching production data

The AI doesn't understand the blast radius of infrastructure changes the way you do. It will happily generate a script that nukes your database if that's technically what you asked for.

For bigger infrastructure stuff, Terraform is great specifically because it has built-in safety mechanisms. But even then—review the plan output before applying.

Always Review, Always Ask Why

This is kind of the meta-lesson that wraps everything else together.

AI coding assistants will give you code. Lots of it. Fast. The temptation is to just ship it and move on. Don't.

What reviewing actually means:

Actually read the code. Not skim—read. Does the logic make sense?
Ask for reasoning. "Why did you use this approach?" is totally valid. If the AI can't explain it well, that's a red flag.
Ask for documentation. Ask the AI to document how things work, or document design decisions etc. post development.
Give feedback. "This is too complex" or "Can we simplify?" pushes it toward better solutions.
Check the edges. AI is great at the happy path. It's often weak on error handling, edge cases, and security stuff.

Wrapping Up

After doing a lot of AI-assisted development, my productivity has genuinely gone way up. But not because the AI replaced my thinking—because it amplified it.

The pattern that works:

You decide the approach. AI implements it.
You validate the output. AI iterates based on your feedback.
You catch the context-specific stuff. AI doesn't know your infrastructure, your security requirements, or your users.
You stay curious. Ask why. Push back. Give direction.

We're the architects.

A.I. — The Amplifier: From Software Developer to Software Creator 🚀

Forrester Terry — Tue, 20 Jan 2026 16:00:00 +0000

A.I. will make the bad "badder", the rich richer, the poor poorer, the hopeful more hopeful, the doubtful more doubtful. It's given people the ability to do more with less—and less with more. It is the double-edged sword that is both blessing and curse.

The question isn't whether A.I. will be good or bad for humanity. It'll be both. We know this.

The real question is: How much of a force multiplier will it be on the things that matter most? And where will that take us?

What I'm Seeing Out There 📊

Let me be honest about what's happening in our industry right now.

Junior developer roles have collapsed. Entry-level tech postings fell 60% between 2022-2024, and Big Tech hired only 7% new grads in 2024. At the same time, the barrier to entry for creating has never been lower. Suno has 12+ million users making music. Over 15 billion AI images have been generated. GitHub Copilot users complete tasks 55% faster.

A.I. makes mistakes AND solves age-old math problems. It takes jobs and creates some. It's used to improve breast cancer detection throughput by 44%, and it's used in warfare and surveillance.

Among all this -- it is the end of software developers as we knew them—and the start of something new: The Software Creator.

❓ "Should I Still Learn Software Development?"

Short answer: Yes. These tools are not bulletproof. Not even close.

What I've Learned About A.I. Capabilities

I think of A.I. agents like employees I'm onboarding. Right now, A.I. performs at junior-to-mid level for routine, well-defined tasks—but falls well below junior on complex system changes and architectural decisions.

Task Type	AI Performance
Single functions (HumanEval)	90-96% ✅
Standard GitHub issues	70-76% 🟡
Complex real-world problems	17-23% ❌

The breadth of knowledge is WIDE, but not DEEP. I learned this the hard way building an AI-powered chatbot for my team—the thing could answer simple questions beautifully, but the moment someone asked something that required understanding our specific infrastructure (or a tool call gave bad info), it would confidently hallucinate an answer that sounded perfect but was completely wrong.

Additionally if you don't know how to ask, "WHY are you doing it that way?" or better yet, "WHOA, please don't do that, do this instead," you'll get taken down a rabbit hole of confident failure.

The Real Productivity Numbers (They're Messier Than You Think)

You've probably heard "AI gets you 80% there." The data tells a more honest story.

GitHub Copilot generates 46% of code for active users, but the acceptance rate averages only 30%—meaning 70% of suggestions get rejected. 66% of developers say their top frustration is "AI solutions that are almost right, but not quite." And here's the kicker: a METR randomized controlled trial found developers actually took 19% longer with AI—while believing they were 20% faster. 🤯

I've felt this myself. There's something intoxicating about watching code appear on your screen. You feel productive. But then you spend an hour debugging something the AI introduced three suggestions ago, and you realize your "80% there" was actually "60% there with new bugs."

Realistic ratio: 60/40 or 70/30. That "last mile" is longer than it looks.

🛠️ What Should You Actually Learn?

You don't need to know everything overnight. I didn't. I came into this field without a computer science degree and learned everything on the job over 11+ years. Buy tools for your garage as you need them—same principle here.

Start With the Foundations

Learn the basics first: variables, functions, classes. These are universal to any modern language. Here's my unpopular opinion: build something simple without A.I. first. That trial-and-error is what makes you stronger. It's what lets you recognize when the AI is leading you astray.

And learn Git. Non-negotiable. This will be important for keeping your code and the A.I.'s code on track.

Then Build Your Stack

Backend fundamentals matter—Firebase, Express/Node, Flask. Understand what an API is and how to stand one up. If you're working with AI agents, TypeScript + Zod (or Pydantic for Python folks) become critical. Type definitions and data validation are how you keep AI-generated code from doing something unexpected at runtime.

Pick up basic testing with Jest or pytest. Here's a common trick I practice: make the AI write tests, then make it run them. It's a forcing function for quality.

Security basics should be non-negotiable too. Don't put secrets in frontend code (I've seen this more than I'd like to admit). Understand OAuth and auth flows. Use a secret manager.

Level Up When You're Ready

Cross-platform frameworks like Electron, Capacitor, and Quasar open up new possibilities when you're ready for them. Docker is technically a "bonus" but honestly, just learn it. Your future self will thank you.

💼 "How Do I Get a Job?"

If You're Starting from Zero

The barrier for entry is higher now. I won't sugarcoat that. But I've hired people, and I can tell you what actually moves the needle.

First, build a real portfolio WITH A.I. Release software on GitHub that's actually useful. Demonstrate you can go from idea to reality. But here's the crucial part: understand it under the hood and be able to explain it. I've interviewed candidates who built impressive-looking projects but couldn't explain basic architectural decisions. That's a red flag.

Second, bring genuine enthusiasm. I'll take someone who's green but humble and eager over someone excellent but difficult to work with every single time. Your soft skills matter more than ever in a world where AI can write code. The human stuff—collaboration, communication, judgment—that's your edge.

Third, develop AI skills beyond basic prompting. Job postings for "prompt engineers" peaked in April 2023 and have plateaued since. Basic prompting is table stakes now. What employers actually want is system design and architecture, MLOps and production deployment, LLM fine-tuning and RAG development, and critical evaluation of AI outputs.

Jobs mentioning AI skills pay a 28% premium (~$18K/year), rising to 43% for multiple AI skills.

If You're Mid-Level or Beyond

~~Move into management because those jobs are safer. Right???~~

Nah. The data actually shows middle managers comprised 32% of 2023 layoffs, and companies like Microsoft, Amazon, and Meta are explicitly flattening org structures. "The Great Flattening" is real. I say this as someone in management—the title alone doesn't protect you.

What actually works is becoming a force multiplier. Use A.I. to do an amazing job at what your employer cares about. I've built reports and automations that would have taken weeks and compressed them into days. That's the kind of thing that gets noticed.

Learn the tools deeply. Explore, play around, but focus on what connects to your actual job. Build with A.I. agents—learn how to orchestrate them, multitask with them, and free up your time for the work that actually requires human judgment.

Lead without the title. Technical design, mentorship, and judgment are human superpowers. No AI is going to sit down with a frustrated junior dev and help them work through impostor syndrome.

This is what transforms you from Software Developer → Software Creator → A.I. Orchestrator.

🎮 How I Got Started with A.I.

Here's roughly how my journey went:

Phase	What I Learned
🎨 Image Gen	Started with Stable Diffusion. Check out Flux, Imagen, Midjourney
💬 Chatbots	ChatGPT, Claude, Gemini. Learned context windows, tokens, prompting
🤖 Coding Agents	Cursor, Windsurf, Claude Code—AI edits code locally
🔧 Building Agents	CrewAI, LangChain, MCP servers
🔬 Deep Research	Gemini Deep Research, NotebookLM for studying
🏠 Running Local	Ollama, vLLM, fine-tuning your own models, RAG

Take it one step at a time. I spent months in each phase before moving to the next. You don't need all of this at once.

⚠️ Real Talk: What's Coming

I'd be crazy to tell you not to be concerned. A lot is changing. But here's how I think about it:

A.I. amplifies what people already do—good and bad. People generally want everyone to be well off (so they can be well off too). And people don't like being squashed or oppressed.

We're going to figure things out, as we have before. But it'll take work.

What About "The Next Big Thing"?

You might hear about transformer alternatives, neurosymbolic AI, quantum computing integration. Here's my honest read on these:

Transformer alternatives like hybrid models exist (Jamba, Granite 4.0), but transformers remain central. We're seeing augmentation, not replacement. Neurosymbolic AI produced impressive results with AlphaGeometry, but no major LLM has shipped a general product yet. And quantum + AI? Jensen Huang estimates 15-30 years for "very useful" applications.

These are research directions to watch, not imminent paradigm shifts. Focus on what works today.

🎯 The Bottom Line

Yes, still learn software development. It's still worthwhile.

But understand this: the role is transforming. The developers who thrive will be the ones who become creators—people who can direct A.I. tools with expertise, know when to trust output and when to override, build entire systems (not just write code), and amplify their output through orchestration.

Be kind to each other, and be kind to yourself. Be curious.

The future will be great and problematic. You need to know how to spot deepfakes, understand security risks, and leverage the tools—otherwise you'll be pushed out.

But you've got this. 🤝

What's your experience with A.I. in your development workflow? Are you a skeptic, an enthusiast, or somewhere in between? Drop a comment below!

I Have Bipolar II and I'm a Software Engineering Manager. Here's What Actually Works.

Forrester Terry — Sun, 18 Jan 2026 17:00:00 +0000

I've been in higher education IT for over 11 years. I've gotten "Exceptional Year" ratings. I manage a team of four devs and a portfolio of 20+ apps.

I also have Bipolar II, diabetes, and I'm a recovering alcoholic — sober since 2020.

If you're a dev managing your own stuff, this is for you. Not quite the “inspirational” version, but real nonetheless.

The Real Version

The performance reviews say things like "force multiplier" and "technical backbone." What they don't capture: the hypomanic phases where I'd fire off more ideas than anyone could implement, followed by crashes where getting out of bed felt impossible. The time I sent an apology email to my entire IT org while manic, outing myself as bipolar to hundreds of people. The years I used alcohol to manage what my brain wouldn't.

When I got sober, I replaced drinking with work. Classic move, right? The dopamine hit of shipping code. The validation of being the guy who solves the "impossible" problems.

Then I lost my brother. And somewhere in the grief, I realized I was going to burn out completely if I didn't change how I thought about all of this.

Your Health Isn't a Side Quest

Here's what took me way too long to accept: managing my health isn't something I do around my job. It IS the job. Everything else comes after. Especially more so as I stepped into leadership and became responsible for others.

Bipolar and diabetes create this feedback loop — mood affects blood sugar, blood sugar wrecks mood, stress spikes everything. It's not a metaphor. It's just how the body works.

I tried to brute-force through it for years. Push harder, sleep less, prove I could keep up. You know where that leads.

Spoon Theory, Basically

If you don't know Spoon Theory: you start each day with limited "spoons" (energy units). Every task costs spoons. When they're gone, they're gone. Borrow from tomorrow and you pay interest in a crashed mood or spiked glucose.

So I stopped organizing work by priority and started organizing by energy cost:

High-energy stuff (architecture, hard conversations) → morning when I'm sharp
Medium stuff (code reviews, meetings) → afternoon
Low-energy stuff (email, docs) → the valleys

I built a hybrid system by literally just talking through my constraints with AI over a bunch of sessions. GTD for capturing everything, time blocking for structure, Pomodoro for pushing through fog. Nothing fancy. Just honest about what I'm actually working with.

The key insight: rest isn't the opposite of work. It's what makes work possible.

Making Myself Less Necessary

Here's the weird part: my limitations made me a better manager.

When you can't be the hero pulling all-nighters, you build systems that don't need heroes. When you know a depressive episode could knock you out for days, you write documentation and processes that let your team function without you.

Practically:

Reusable code libraries so we're not reinventing stuff
Documentation that's actually useful (AI memory, not bureaucracy)
Mentoring junior devs into mentors themselves
Automating the tedious stuff — CI/CD, release notes, deployments

The goal is to make myself progressively less necessary. Sounds bad for career advancement, but actually? The good orgs reward people who elevate everyone around them, not people who hoard knowledge.

The Humbling Part

I gotta be honest: I've watched people who output less than me get more recognition. And a lot of the time, they deserved it.

Because they were consistent. Reliable. They showed up steady every day.

When you're managing Bipolar, consistency is hard. Hypomania feels productive but creates chaos. Depression tanks your reliability. Boom-and-bust might average to high output, but it's not the same as being someone people can count on.

My work feedback survey shows I rate myself way harsher than my team does — like 2 out of 5 on stuff they score me 4.6. That gap is years of feeling like I had to compensate for my brain by being visibly exceptional.

The truth: sustainable and reliable beats exceptional and erratic. Every time.

Environment Matters More Than Salary

I work in higher ed, not FAANG. Not where the big money is. This is intentional.

I've had the same leadership for 11+ years and enjoy working with my directorl. When I've struggled — visibly — I wasn't managed out. I was supported. That kind of psychological safety is worth more than any salary bump I'd get jumping to a high-pressure gig.

If you're managing chronic stuff, environment isn't a perk. It's infrastructure. The right manager, the right culture, the right flexibility — that's what makes everything else possible.

The Short Version

If you're a dev fighting similar battles:

Don’t pretend that you have the same resources as everyone else. You don't. Build systems for your actual constraints.
Energy management > time management. Know your peaks and valleys.
Rest is productive. For real.
Make yourself less necessary. Document, automate, mentor.
Consistency beats intensity. 70% every day beats 150% half the time.
Environment is infrastructure. A good manager isn't a luxury.
Your inner critic lies. Get external feedback. Trust it more than the voice saying you're not enough.
Work can be an addiction too. Ask me how I know.

Work-life balance isn't a myth. For some of us, it's a survival strategy.

I'm not writing this from the other side, all figured out. I'm in the middle, still managing the loops, still learning what sustainable looks like.

But I'm still here doing my thing. Still shipping code. Still leading a team.

If you're fighting similar stuff — you can do this.

Not by pretending you don't have limits, but by building systems that work with them.

That's not settling. That's engineering.

If this resonates at all or made you think about something else, I'd love to hear from others.

Part 1 : Building a Game in 30 Hours Using AI — Here's the Actual Timeline

Forrester Terry — Fri, 16 Jan 2026 00:22:34 +0000

What happens when you treat AI as a development partner instead of an autocomplete tool?

I wanted to find out, so I ran an experiment: build a game as fast as possible, prioritizing speed and iteration over polish. No extensive planning phase. No detailed specs. Just prototyping at velocity to see what's actually possible.

The result is MagLava—a magnetic platformer where you swing between nodes to escape rising lava. Six development sessions. Roughly 30 hours of work. A published game with 25 levels, 7 language translations, and a desktop app.

To be clear: this approach was the point of the experiment. For production software or anything beyond rapid prototyping, proper planning and testing remain essential (I plan to make a post around that later).

But I wanted to stress-test the other extreme.

Here's exactly how that broke down.

The Commit Log

I commit frequently using an AI tool that generates summaries after each task, so commit clusters map well to actual work sessions. I went through my git history and reconstructed the timeline:

Date	Commits	Estimated Time	What Happened
Dec 18	2	~1.5 hours	Project scaffold, Vue + Phaser setup
Dec 19	3	~2-3 hours	Core magnetic polarity system
Dec 20	27	~8-12 hours	Complete movement redesign + 15 levels
Dec 21	9	~4-6 hours	Mobile controls, tutorials, PWA
Dec 30	13	~5-7 hours	Desktop app, music, polish
Jan 15	8	~3-5 hours	i18n (7 languages), expand to 25 levels

Total: ~25-35 hours across 6 sessions.

Notice the gaps. Nine days between Dec 21 and Dec 30. Sixteen days before the final session. The calendar says "one month of development." The reality is about a week of actual work, scattered across that month.

What "AI-Assisted" Actually Meant

The first day alone produced 6,555 lines of code—project structure, game config, menu systems, routing, storage services, the event bridge between Vue and Phaser. That's scaffolding I would have spent days on manually.

But the surprising part wasn't the code generation. It was what else came out of the process.

The promotional website with SEO, sitemaps, and structured data? AI-built. The full Electron desktop app with the level editor? Same story. The internationalization system supporting 7 languages? Implemented in a single session.

I didn't set out to have AI handle all of these. They emerged because once you're in a flow state with an AI partner, the friction for "one more feature" drops dramatically. Adding a desktop build went from "future roadmap item" to "let's just do it this session."

The Method Behind the Numbers

You might have heard the term "vibe coding"— in this case, staying in player mode and describing problems experientially rather than technically. That's what this looked like in practice. Here's an actual prompt from one of my sessions:

"game just freezes! I can't actually SEE the LAVA LINE!!! I WANA SEE THE LAVA line. And finally, we start way too close to the lava."

Typos, caps lock, frustration—all of it. I didn't calculate a pixel buffer. I expressed a feeling of unfairness. The AI translated "way too close" into a concrete fix: increasing the spawn buffer from 150 to 500 pixels above the lava line.

This only works because emotion is a valid technical spec when your goal is player experience. "This feels unfair" contains more design information than "adjust the Y-offset parameter."

Why the Timeline Matters

I'm not claiming 30 hours is fast or slow. Game complexity varies wildly. What I am claiming is that this timeline was possible because of how I worked, not just the tools I used.

The traditional solo dev pipeline looks like this: plan extensively, build the architecture, implement features, then test. You front-load decisions before you have information.

My pipeline inverted that. Build something immediately. Play it. Describe what feels wrong. Iterate. The AI handled the translation from "this sucks" to "here's the code change."

Every system stayed disposable. Every change stayed focused and modular. When something wasn't working, I didn't defend it—I described a different vision and let it get rebuilt. That's hard to do when you've personally written every line. It's easy when you're directing rather than typing.

What the Numbers Don't Show

The timeline looks clean in retrospect. It wasn't.

Day 3—that massive 27-commit session—included throwing away the entire movement system I'd built on Day 2. The original concept was polarity-based climbing: red platforms attract, blue platforms repel. I built the whole thing. Then I played it and it felt indirect, frustrating, disconnected from what I actually wanted.

So I described something different: "I want swinging. Like Spider-Man but with magnets."

Within hours, the game had a completely new identity.

That pivot—and one other major pivot that came later—are probably the reason MagLava works at all. But that's a longer story.

Next in this series: The two pivots that almost killed the project, and why emotional prompts caught problems that specs would have missed.

Play MagLava | itch.io page

Tech stack for the curious: Vue 3 + Vite, Phaser 3, TypeScript, Electron for desktop, Firebase + itch.io for hosting, Claude (Opus via Claude Code CLI) for AI assistance.

Supercharging Your AI Agents with Pydantic: A Developer's Guide 🚀

Forrester Terry — Fri, 28 Feb 2025 04:33:15 +0000

Introduction 👋
What is Pydantic and Why Should AI Developers Care? 🤔
- The AI Agent's Output Problem 🤖💬
How Pydantic Makes AI Agents More Reliable 🛡️
- 1. Automatic Type Conversion
- 2. Clear Error Messages
- 3. Schema Generation for Guiding AI Outputs
Real-World Use Cases 🌍
- OpenAI Function Calling + Pydantic
- Multi-Agent Systems (CrewAI)
Best Practices for Using Pydantic with AI Agents ✅
- 1. Start with a Clear Data Model
- 2. Handle Validation Errors Gracefully
- 3. Consider Re-Prompting When Validation Fails
A Simple Tutorial: Getting Started with Pydantic and AI 🏗️
- Step 1: Define Your Pydantic Model
- Step 2: Create a Function to Get Recommendations from an AI
- Step 3: Use the Recommendation in Your Application
Advanced Tips and Tricks 🧠
- Custom Validators for Domain-Specific Rules
- Nested Models for Complex Data
- Working with LangChain's Pydantic Output Parser
Conclusion 🎯

Introduction 👋

Have you ever built an AI agent that sometimes returns unpredictable data structures? Or perhaps you've dealt with the frustration of parsing JSON from a language model only to have your application crash because a field was missing or had the wrong type?

I've been there too! That's why today I want to talk about one of my favorite tools for taming the wild outputs of AI agents: Pydantic!

In this guide, I'll show you how Pydantic can transform your AI agent development from a game of chance into a reliable, robust process. Let's dive in! 🏊‍♂️

What is Pydantic and Why Should AI Developers Care? 🤔

Pydantic is a Python library for data validation that uses type annotations. Think of it as a bouncer for your data - it checks IDs (types) at the door and makes sure only the right data gets into your application.

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int
    is_active: bool

But why is this particularly useful for AI agents? Here's the thing:

AI models (especially LLMs) are amazing at generating content, but they're not always precise about formatting. They might return JSON where a number is accidentally a string ("42" instead of 42), or they might forget a field entirely. Without validation, these small inconsistencies can cause big problems downstream in your application.

The AI Agent's Output Problem 🤖💬

Imagine asking an AI agent to return information about a product:

{
  "name": "Super Widget",
  "price": "29.99",
  "in_stock": "true",
  "features": ["durable", "lightweight"]
}

Notice the issues? price is a string instead of a float, and in_stock is a string instead of a boolean. Your application might crash when it tries to do math with that price or make a decision based on the stock status.

Pydantic to the rescue! It can automatically convert these types for you, so "29.99" becomes 29.99 (float) and "true" becomes True (boolean).

How Pydantic Makes AI Agents More Reliable 🛡️

1. Automatic Type Conversion

Pydantic doesn't just validate - it tries to convert data to the right type when possible. This is perfect for AI outputs that are almost correct.

from pydantic import BaseModel

class Product(BaseModel):
    name: str
    price: float
    in_stock: bool
    features: list[str]

# Even though price and in_stock are strings, Pydantic will convert them
product = Product(
    name="Super Widget", 
    price="29.99", 
    in_stock="true",
    features=["durable", "lightweight"]
)

print(product)
# Product(name='Super Widget', price=29.99, in_stock=True, features=['durable', 'lightweight'])

2. Clear Error Messages

When validation fails, Pydantic tells you exactly what went wrong:

try:
    Product(name="Broken Widget", price="expensive", in_stock=True, features="strong")
except Exception as e:
    print(f"Error: {e}")

# Error: 2 validation errors for Product
# price
#   Input should be a valid number, unable to parse string as a number [type=float_parsing, input_value='expensive', input_type=str]
# features
#   Input should be a valid list [type=list_type, input_value='strong', input_type=str]

These detailed errors make debugging so much easier when your AI agent returns unexpected data.

3. Schema Generation for Guiding AI Outputs

One of my favorite Pydantic features for AI development is its ability to generate JSON schemas:

print(Product.model_json_schema())
# {
#   "title": "Product",
#   "type": "object",
#   "properties": {
#     "name": {"title": "Name", "type": "string"},
#     "price": {"title": "Price", "type": "number"},
#     "in_stock": {"title": "In Stock", "type": "boolean"},
#     "features": {
#       "title": "Features",
#       "type": "array",
#       "items": {"type": "string"}
#     }
#   },
#   "required": ["name", "price", "in_stock", "features"]
# }

You can use this schema to guide your AI model, especially if you're using function calling with OpenAI or similar features with other providers. This dramatically improves the chances of getting correctly formatted responses!

Real-World Use Cases 🌍

Let's look at how developers are using Pydantic with AI agents in the wild:

OpenAI Function Calling + Pydantic

from openai import OpenAI
from pydantic import BaseModel, Field

class WeatherInfo(BaseModel):
    location: str = Field(..., description="The city and state")
    temperature: float = Field(..., description="Current temperature in Celsius")
    condition: str = Field(..., description="Weather condition (sunny, cloudy, etc.)")

# Get the JSON schema for OpenAI
function_def = {
    "name": "get_weather",
    "description": "Get the current weather in a location",
    "parameters": WeatherInfo.model_json_schema()
}

client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "user", "content": "What's the weather like in Boston?"}
    ],
    functions=[function_def],
    function_call={"name": "get_weather"}
)

# Extract and validate the response
function_response = response.choices[0].message.function_call.arguments
weather = WeatherInfo.model_validate_json(function_response)
print(f"It's {weather.temperature}°C and {weather.condition} in {weather.location}")

This approach has two benefits:

The schema guides the AI to produce properly structured output
Pydantic validates that output as an extra safety measure

Multi-Agent Systems (CrewAI)

In systems where multiple AI agents collaborate, consistent data structures are critical. Frameworks like CrewAI use Pydantic to ensure agents communicate properly:

from pydantic import BaseModel
from crewai import Agent, Task, Crew

class ResearchReport(BaseModel):
    topic: str
    key_findings: list[str]
    sources: list[str]

# Define a task with a Pydantic output schema
research_task = Task(
    description="Research the latest advancements in quantum computing",
    expected_output="A structured research report with key findings and sources",
    output_pydantic=ResearchReport
)

# When the agent completes the task, CrewAI validates the output against the model

Best Practices for Using Pydantic with AI Agents ✅

After working with numerous AI projects, here are my top recommendations:

1. Start with a Clear Data Model

Define Pydantic models that capture exactly what you need from your AI agent. Be specific about types and constraints:

from typing import Optional, Literal
from pydantic import BaseModel, Field, conint

class ProductRecommendation(BaseModel):
    product_name: str
    price_range: str = Field(..., pattern=r"^\$\d+-\$\d+$")  # Ensure format like "$10-$20"
    rating: conint(ge=1, le=5)  # Integer between 1-5
    category: Literal["electronics", "clothing", "home", "books", "other"]
    features: list[str] = Field(..., min_items=2, max_items=5)
    in_stock: bool
    shipping_days: Optional[int] = None

This detailed model serves as documentation and validation in one package.

2. Handle Validation Errors Gracefully

Always wrap your Pydantic validation in try/except blocks:

try:
    recommendation = ProductRecommendation.model_validate_json(ai_response)
    # Use the structured data
except Exception as e:
    # Log the error
    print(f"AI output validation failed: {e}")

    # Possible strategies:
    # 1. Use a fallback approach
    # 2. Re-prompt the AI with the error details
    # 3. Apply some fixes and retry validation

3. Consider Re-Prompting When Validation Fails

One powerful approach is to tell the AI exactly what went wrong and ask it to fix the response:

def get_validated_response(prompt):
    for attempt in range(3):  # Try up to 3 times
        response = ai_model.generate(prompt)

        try:
            result = ProductRecommendation.model_validate_json(response)
            return result
        except Exception as e:
            if attempt < 2:  # Don't update prompt on the last attempt
                prompt += f"\nYour previous response had validation errors: {e}. Please fix them and try again."

    # If we get here, all attempts failed
    raise ValueError("Could not get valid response after multiple attempts")

This feedback loop helps the AI learn from its mistakes!

A Simple Tutorial: Getting Started with Pydantic and AI 🏗️

Let's bring everything together with a simple tutorial. We'll create a movie recommendation agent that returns properly structured data:

Step 1: Define Your Pydantic Model

from pydantic import BaseModel, Field
from typing import List, Optional

class MovieRecommendation(BaseModel):
    title: str
    year: int = Field(..., ge=1900, le=2030)
    genres: List[str] = Field(..., min_items=1)
    rating: float = Field(..., ge=0.0, le=10.0)
    director: str
    streaming_on: Optional[List[str]] = None
    description: str = Field(..., max_length=500)

Step 2: Create a Function to Get Recommendations from an AI

def get_movie_recommendation(genre_preference, mood, decade_preference=None):
    # Construct a prompt for the AI
    prompt = f"""
    Suggest a movie based on the following:
    Genre preference: {genre_preference}
    Mood: {mood}
    Decade preference: {decade_preference or 'any'}

    Return the recommendation as a JSON object with the following fields:
    - title: the movie title
    - year: the release year (1900-2030)
    - genres: list of genres
    - rating: rating out of 10
    - director: the director's name
    - streaming_on: list of streaming platforms (if known) or null
    - description: brief description (max 500 chars)
    """

    # In a real application, you'd call your AI model here
    # For demonstration, let's pretend we got this response:
    ai_response = """
    {
      "title": "The Grand Budapest Hotel",
      "year": 2014,
      "genres": ["Comedy", "Drama", "Adventure"],
      "rating": 8.1,
      "director": "Wes Anderson",
      "streaming_on": ["HBO Max", "Disney+"],
      "description": "A writer encounters the owner of an aging high-class hotel, who tells him of his early years serving as a lobby boy in the hotel's glorious years under an exceptional concierge."
    }
    """

    try:
        # Parse and validate the AI response
        recommendation = MovieRecommendation.model_validate_json(ai_response)
        return recommendation
    except Exception as e:
        print(f"Error validating AI response: {e}")
        # In a real application, you might implement retry logic here
        return None

Step 3: Use the Recommendation in Your Application

def display_recommendation(recommendation):
    if not recommendation:
        return "Sorry, couldn't generate a valid recommendation."

    return f"""
    🎬 {recommendation.title} ({recommendation.year}) - {recommendation.rating}/10

    Directed by: {recommendation.director}
    Genres: {', '.join(recommendation.genres)}

    {recommendation.description}

    {f"Available on: {', '.join(recommendation.streaming_on)}" if recommendation.streaming_on else "Streaming info not available"}
    """

# Get and display a recommendation
user_genre = "sci-fi"
user_mood = "thoughtful"
user_decade = "2010s"

movie = get_movie_recommendation(user_genre, user_mood, user_decade)
print(display_recommendation(movie))

Advanced Tips and Tricks 🧠

Want to take your Pydantic + AI game to the next level? Here are some advanced techniques:

Custom Validators for Domain-Specific Rules

from pydantic import BaseModel, Field, validator

class TravelRecommendation(BaseModel):
    destination: str
    best_months: list[str]
    budget_usd: int = Field(..., gt=0)

    @validator('best_months')
    def check_valid_months(cls, months):
        valid_months = ["January", "February", "March", "April", "May", "June", 
                      "July", "August", "September", "October", "November", "December"]

        for month in months:
            if month not in valid_months:
                raise ValueError(f"Invalid month: {month}")
        return months

Nested Models for Complex Data

class Address(BaseModel):
    street: str
    city: str
    state: str
    country: str
    postal_code: str

class Contact(BaseModel):
    name: str
    email: str
    phone: Optional[str] = None
    address: Address

class BusinessListing(BaseModel):
    name: str
    category: str
    rating: float
    contact: Contact
    hours: dict[str, str]

Working with LangChain's Pydantic Output Parser

from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from pydantic import BaseModel, Field

class AmazonProduct(BaseModel):
    name: str = Field(description="The product name")
    price: float = Field(description="The product price in USD")
    rating: float = Field(description="Rating from 1-5")
    reviews: int = Field(description="Number of reviews")

parser = PydanticOutputParser(pydantic_object=AmazonProduct)

prompt = PromptTemplate(
    template="Extract product information from this text:\n{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

model = OpenAI()

input_text = """
This amazing laptop is the MacBook Pro 16-inch, priced at $2,399. It has received 
excellent feedback from customers, with a 4.8 star rating based on 3,842 reviews.
"""

output = model(prompt.format(text=input_text))
product = parser.parse(output)

Conclusion 🎯

Pydantic is more than just a validation library - it's your AI agent's best friend! By defining clear data models and validating inputs and outputs, you can:

Make your AI applications more reliable
Catch errors early before they cascade into bigger problems
Guide your models to produce better-structured outputs
Create self-documenting code that clearly specifies what data you expect

The next time you're building an AI agent, take the time to define your data models with Pydantic. Your future self (and your users) will thank you!

Have you used Pydantic with AI projects? Feel free to share your experiences in the comments!

TypeScript Fundamentals: A Beginner's Guide (2025) ✅

Forrester Terry — Tue, 07 Jan 2025 02:33:01 +0000

TypeScript has caused endless debates among developers. Some see it as a bureaucratic roadblock to the freedom of JavaScript, while others hail it as a beacon of light in the trenches of loosely typed code. Love it or hate it, TypeScript is here to stay — and once you get to know it, you might just find it’s not a burden but a blessing for your projects.

In this series we will explore TypeScript and cover the basics -- as well as some tricks and troubleshooting tips.

1. Introduction

What is TypeScript?

TypeScript is a statically typed superset of JavaScript that compiles to plain JavaScript. In simpler terms, it’s JavaScript with extra features that help you catch errors early and write better, more maintainable code.

Think of TypeScript as a friendly assistant who double-checks your work before you submit it. It lets you:

Spot errors while you’re coding, not after you’ve deployed.
Write code that’s easier to read and understand.
Scale your projects without losing track of how things connect.

Why Use TypeScript?

Let’s get practical. Why should you care about TypeScript when JavaScript already works?

Real Benefits:

Catch Errors Early: Avoid common pitfalls, like passing the wrong data type to a function.

   function greet(name: string) {
     return `Hello, ${name}!`;
   }
   greet(42); // Error: Argument of type 'number' is not assignable to parameter of type 'string'.

Autocompletion & Documentation: Modern editors (like VS Code) provide rich autocomplete suggestions and documentation as you type.
Code Scalability: TypeScript’s features shine in larger projects where maintaining consistency is key.
Improved Team Collaboration: Clear types make it easier for team members to understand your code at a glance.

I have found TypeScript to be particularly helpful for planning out bigger apps; understanding what types of data I will be dealing with and what data my functions take/return.

Prerequisites

Before diving in, ensure you have basic JavaScript knowledge. You should be familiar with:

Variables and data types (e.g., let, const, string, number)
Functions
Arrays and objects

If you’re not confident yet, take some time to review JavaScript basics.

2. Setting Up Your Environment

Installing TypeScript

TypeScript is a tool that requires installation to get started. With just a few steps, you can prepare your environment to begin coding in TypeScript. Here’s how to do it:

To start using TypeScript, you’ll need Node.js installed. Once you have that:

Install TypeScript globally:

   npm install -g typescript

Verify the installation:

   tsc --version

Setting Up VS Code

VS Code is one of the most popular editors for TypeScript development. It provides a range of features and extensions that make coding easier and more efficient. Let’s set it up:

VS Code is the go-to editor for TypeScript developers. Here’s how to set it up:

Install VS Code: Download here
Add these helpful extensions:
- ESLint: For linting your TypeScript code.
- Prettier: For consistent code formatting.
- TypeScript Hero: For improved productivity.

Creating Your First TypeScript Project

Getting hands-on is the best way to learn TypeScript. This section guides you through setting up your first project, from creating files to running your code.

Create a new folder for your project and navigate into it:

   mkdir typescript-starter
   cd typescript-starter

Initialize a new project:

   npm init -y

Add TypeScript:

   npm install --save-dev typescript

Create a tsconfig.json file:

   npx tsc --init

Write your first TypeScript file:

   echo "console.log('Hello, TypeScript!');" > index.ts

Compile and run:

   npx tsc index.ts
   node index.js

You’ve just written and compiled your first TypeScript program!

3. Basic Types Overview

TypeScript’s power lies in its type system. Let’s explore some basic types:

Primitive Types

Primitive types are the building blocks of TypeScript’s type system. They include basic data types like strings, numbers, and booleans. Here’s a quick look at how to use them:

string:

   let name: string = "Alice";

number:

   let age: number = 25;

boolean:

   let isStudent: boolean = true;

Advanced Types

In addition to primitives, TypeScript supports more complex types like arrays, tuples, and special types like any and unknown. These types make your code flexible while maintaining safety.

Arrays:

   let scores: number[] = [90, 85, 88];

Tuples:

   let user: [string, number] = ["Alice", 25];

any (use sparingly):

   let data: any = "Could be anything";

unknown (safer than any):

   let value: unknown = 10;

void (functions that return nothing):

   function logMessage(message: string): void {
     console.log(message);
   }

null and undefined:

   let something: null = null;
   let nothing: undefined = undefined;

4. First Steps with Type Annotations

Type Annotations in TypeScript allow developers to specify the type of a variable, parameter, or function return value. This ensures that the code adheres to a defined structure, making it easier to catch errors during development and maintain consistency throughout the project.

As you write your code as you normally do, take note of the features below that you can integrate

Basic Variable Typing

Set types for your variables so that they are always set to the right thing, and the rest of the app understands what they are.

let firstName: string = "Alice";
let age: number = 30;

Function Parameter Typing

Similarly, for functions you can define the types for the arguments, as well define the type for the return.

// Note the 'number' keywords for each param
function add(a: number, b: number): number { 
  return a + b;
}

Return Type Annotations

// Note the 'string' keyword at the end
function greet(name: string): string { 
  return `Hello, ${name}!`;
}

Practical Example: User Profile

TypeScript allows you to declare your own types to better structure and enforce rules in your code. By using type or interface, you can define custom types for objects, functions, or even unions. This not only makes your code more robust but also improves readability and consistency in larger projects.

interface UserProfile = {
  name: string;
  age: number;
  isActive: boolean;
};

const user: UserProfile = {
  name: "Alice",
  age: 25,
  isActive: true,
};

5. Quick Start with Interfaces

Basic Syntax

Interfaces in TypeScript define the structure of objects, ensuring they have specific properties and types. This section shows you how to create and use them:

interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "Bob",
  age: 30,
};

Optional Properties

Sometimes, not all properties in an object are required. TypeScript lets you define optional properties in interfaces to handle such cases gracefully.

interface Product {
  name: string;
  price?: number;
}

const item: Product = { name: "Notebook" };

Readonly Properties

Readonly properties are useful when you want to ensure certain values cannot be changed after they are set. Here’s how to use them in interfaces:

interface Book {
  readonly title: string;
}

const myBook: Book = { title: "TypeScript Handbook" };
// myBook.title = "Another Title"; // Error: Cannot assign to 'title'.

Real-World Example: API Response

Using interfaces to type API responses ensures you handle data from servers safely and effectively. Here’s a practical example:

interface ApiResponse {
  data: unknown;
  status: number;
}

6. Practice Project: Building a Simple Todo List

Practice is key to mastering TypeScript. In this project, you’ll create a simple todo list application that leverages the features you’ve learned so far:

Create a Todo type:

   interface Todo {
     id: number;
     title: string;
     completed: boolean;
   }

Build a simple array of todos:

   const todos: Todo[] = [
     { id: 1, title: "Learn TypeScript", completed: false },
   ];

Add some functions to add todos and mark todos as complete:

   function markAsComplete(todo: Todo): Boolean {
        let bUpdated = false
        todos.map((td:Todo) => {
            if (td.id == todo.id){
                bUpdated = true
                td.completed = true
            }
        })
        return bUpdated
   }

   function addToDo(todo:Todo): Boolean{
        try {
            todos.push(todo)
            console.log(`Added "${todo.title}"" to list!`)
            return true
        } catch {
            console.log("Error adding to the todo object!")
            return false
        }
   }

7. Next Steps

That's it for now, hope you enjoyed this tutorial. I will be working on some additional tutorials to dig deeper into useful TypeScript features and use cases.

Coming Up Next: Deep dive into TypeScript functions and advanced types.
Resources:
- TypeScript Documentation
- CodeSandbox for practicing TypeScript online.
Challenge: Create a TypeScript interface for a blog post and use it to type-check a list of blog posts.

See you next time!

📦 How to Create, Publish, and Maintain a Node.js Package (in JavaScript and TypeScript)

Forrester Terry — Mon, 06 Jan 2025 03:59:40 +0000

Have you ever written a piece of code that could benefit other developers — or even your future self—over and over again? Perhaps it’s a utility function, a library, or a set of reusable tools you find yourself copying and pasting across multiple projects.

This might be the perfect candidate for an NPM package!

In this article, we’ll walk step-by-step through creating a simple Node.js package in both JavaScript and TypeScript, setting up best practices such as testing and versioning, and then publishing it to npmjs.com. 🚀

1. Setting Up Your Project

2. Writing Your Package Code

3. Testing Your Package

4. Versioning Best Practices

5. Publishing Your Package

6. Common Features and Best Practices

7. Use Cases

8. Creating Scripts to Automate Common Tasks

1. Setting Up Your Project

1.1 Prerequisites

Node.js (v22.12.0 LTS is recommended as of January 2025, v18 LTS is the oldest version that is still maintained).
npm (comes bundled with Node).
A npmjs.com account for publishing your package.

1.2 Initialize Your Project

Create a new directory for your package:

mkdir my-awesome-package
cd my-awesome-package

Initialize a new Node.js project:

npm init

This command will ask several questions to help create a package.json file, the heart of your Node.js package. Key fields to pay attention to:

name: The name of your package (must be unique in the npm registry).
version: The version of your package, often starting at 1.0.0.
description: A brief explanation of your package.
entry point: The main file (often index.js or dist/index.js).
author: Your name or organization.
license: The license type (e.g., MIT).

You can skip the Q&A by running npm init -y to get a default package.json file.

2. Writing Your Package Code

We’ll explore two approaches: plain JavaScript and TypeScript. Choose whichever suits your project needs—or maintain both if you like.

2.1 Plain JavaScript Version

Create a file named index.js in your project root:

// index.js

/**
 * Returns a greeting message
 * @param {string} name - The name to greet
 * @return {string} A greeting message
 */
function greet(name) {
  return `Hello, ${name}!`;
}

// Export the function as a module
module.exports = greet;

2.2 TypeScript Version

2.2.1 Install and Initialize TypeScript

Install Typescript as a development dependency:

npm install --save-dev typescript

Initialize a tsconfig.json:

npx tsc --init

2.2.2 A Recommended tsconfig.json

Replace the generated tsconfig.json with a configuration tailored for your needs, here we configure for modern Node.js (v22.12.0 LTS):

{
  "compilerOptions": {
    "target": "ES2020",                        // Modern JavaScript features
    "module": "CommonJS",                      // Node.js module system
    "rootDir": "src",                          // Source files directory
    "outDir": "dist",                          // Compiled output directory
    "strict": true,                            // Enable all strict type-checking options
    "esModuleInterop": true,                   // Better compatibility with CommonJS modules
    "skipLibCheck": true,                      // Skip type checking of declaration files for faster builds
    "forceConsistentCasingInFileNames": true,  // Enforce consistent file name casing
    "declaration": true,                       // Generate .d.ts files for type definitions
    "declarationMap": true                     // Generate source maps for declarations
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "**/*.test.ts"]
}

This ensures compatibility with modern JavaScript and enforces strict type-checking, improving code quality.

2.2.3 Create Your Source File

Create a src directory and add index.ts:

// src/index.ts

/**
 * Returns a greeting message
 * @param name - The name to greet
 * @returns A greeting message
 */
export function greet(name: string): string {
  return `Hello, ${name}!`;
}

2.2.4 Update package.json

We need to point main at the compiled JavaScript file in dist, and also specify where the type definitions live via the "types" field. We’ll also add a build script:

{
  "name": "my-awesome-package",
  "version": "1.0.0",
  "description": "A package that greets the user.",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "scripts": {
    "build": "tsc",
    "test": "jest"
  },
  "author": "Your Name",
  "license": "MIT"
}

By specifying "types": "dist/index.d.ts", consumers of your package automatically get the TypeScript definitions.

Now, you can compile your TypeScript source by running:

npm run build

3. Testing Your Package

Testing is not mandatory for publishing but is highly recommended to ensure reliability. We’ll demonstrate using Jest for both JavaScript and TypeScript.

3.1 Install Jest

npm install --save-dev jest

For TypeScript, also install ts-jest and type definitions:

npm install --save-dev ts-jest @types/jest

3.2 Configure Jest (TypeScript Only)

Initialize Jest with TypeScript support:

npx ts-jest config:init

This creates a jest.config.js (or jest.config.ts) file tailored for TypeScript. Typically, it might look like:

// jest.config.js
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node'
};

3.3 Write Your Tests

Create a test directory. Let’s name our test file greet.test.js or greet.test.ts, depending on your language choice.

3.3.1 JavaScript Test Example

// test/greet.test.js
const greet = require('../index'); // Using JavaScript's require

test('returns a greeting with the given name', () => {
  expect(greet('Alice')).toBe('Hello, Alice!');
});

3.3.2 TypeScript Test Example

// test/greet.test.ts
import { greet } from '../src/index'; // or '../dist/index' after build

test('returns a greeting with the given name', () => {
  expect(greet('Alice')).toBe('Hello, Alice!');
});

3.4 Update package.json for Testing

Ensure your package.json includes:

{
  "scripts": {
    "build": "tsc",
    "test": "jest"
  }
}

Now you can build and test your project via:

npm run build
npm test

4. Versioning Best Practices

Node packages typically follow SemVer (Semantic Versioning):

MAJOR for incompatible API changes.
MINOR for adding functionality in a backward-compatible manner.
PATCH for backward-compatible bug fixes.

Example: 1.0.0 (Major.Minor.Patch)

To increment your package version (and create a Git tag if you’re using Git):

npm version patch   # e.g., 1.0.0 -> 1.0.1
npm version minor   # e.g., 1.0.1 -> 1.1.0
npm version major   # e.g., 1.1.0 -> 2.0.0

5. Publishing Your Package

5.1 Log in to npm

Before you can publish, authenticate with npm:

npm login

Enter your credentials and/or token. If you haven’t created an account yet, sign up here.

Alternatively, you can setup your .npmrc to handle the authentications:

echo //registry.npmjs.org/:_authToken=MY_TOKEN > ~/.npmrc

You can change the registry path as needed, depending on your NPM repository instance. For instance, for GitHub you may do:

echo //npm.pkg.github.com/:_authToken=MY_TOKEN > ~/.npmrc

5.2 Publish

For a plain JavaScript package:

npm publish

For a TypeScript package, build your code before publishing:

npm run build
npm publish

Your package is now live on the npm registry, and anyone can install it with:

npm install my-awesome-package

If your package name is scoped (e.g., @your-scope/my-awesome-package), you might need:

npm publish --access public

(--access public is required for scoped packages to be publicly available.)

6. Common Features and Best Practices

6.1 README.md

A clear README.md is essential for explaining your package. Include:

Installation Instructions

  npm install my-awesome-package

Basic Usage

  // JavaScript:
  const greet = require('my-awesome-package');
  console.log(greet('Alice')); // Hello, Alice!

  // TypeScript:
  import { greet } from 'my-awesome-package';
  console.log(greet('Alice')); // Hello, Alice!

Advanced Examples: Show more use cases, configuration, or integration details.
API Documentation: If your package has multiple methods or classes, document them thoroughly.

6.2 LICENSE

Including a license clarifies how your package can be used. Define it in:

A LICENSE file at the root.
The license field in package.json.

6.3 GitHub Repository

While not strictly required, hosting your package on a platform like GitHub helps with:

Collaboration (issues, pull requests)
Version Control (Git tags, branches)
Automated CI (running tests on each commit)

6.4 Linting

Use a linter like ESLint for consistent coding standards.

npm install --save-dev eslint
npx eslint --init

Configure your lint rules, then run:

npm run lint

6.5 Continuous Integration (CI)

For open-source or team projects, consider GitHub Actions, Travis CI, or similar. This ensures tests run automatically on every commit, increasing confidence and catching issues early.

6.6 Adding Dependencies and Managing Dependency Files

As your package grows, you might need to incorporate other libraries or tools to enhance its functionality. Managing dependencies effectively ensures that your package remains robust, maintainable, and easy for others to use.

6.6.1. Adding Dependencies

Dependencies are packages required for your package to run correctly. DevDependencies are packages needed only during development, such as testing frameworks or build tools.

To add a runtime dependency:

  npm install lodash

This command adds the lodash library as a dependency and updates your package.json:

  {
    "dependencies": {
      "lodash": "^4.17.21"
    }
  }

To add a development dependency:

  npm install --save-dev eslint

This adds eslint as a devDependency:

  {
    "devDependencies": {
      "eslint": "^8.0.0"
    }
  }

6.6.2. Managing Dependency Files

package.json: This file lists all your dependencies and devDependencies. Ensure that all necessary packages are correctly listed to avoid missing dependencies during installation.
package-lock.json: Automatically generated when you install dependencies, this file locks the versions of your dependencies to ensure consistent installations across different environments. Do not manually edit this file; instead, let npm manage it.

6.6.3. Best Practices

Keep Dependencies Updated: Regularly update your dependencies to incorporate the latest features and security patches. You can use tools like npm-check-updates to assist with this.

  npm install -g npm-check-updates
  ncu -u
  npm install

Minimize Dependencies: Only include packages that are essential for your package’s functionality. Fewer dependencies reduce the risk of conflicts and vulnerabilities.
Use Peer Dependencies When Appropriate: If your package is a plugin or extension that relies on a host package (like React), specify it as a peer dependency to avoid version conflicts.

  npm install --save-peer react

Update your package.json:

  {
    "peerDependencies": {
      "react": "^17.0.0"
    }
  }

6.6.4. Example: Adding a Dependency

Suppose you want to use axios for making HTTP requests in your package.

Install axios as a dependency:

   npm install axios

Use axios in your code:

   // src/index.ts
   import axios from 'axios';

   /**
    * Fetches user data from an API
    * @param userId - The ID of the user
    * @returns User data
    */
   export async function fetchUserData(userId: number): Promise<any> {
     const response = await axios.get(`https://api.example.com/users/${userId}`);
     return response.data;
   }

7. Use Cases

Utility Packages
- E.g., date-formatting libraries to simplify working with dates.
UI Components
- E.g., a set of React or Vue components published as a standalone package.
CLI Tools
- E.g., command-line utilities for scaffolding projects or automating tasks.
Libraries for APIs
- E.g., wrappers for third-party APIs or microservices, making them easy to integrate with Node.js.

8. Creating Scripts to Automate Common Tasks

To streamline your development workflow, it's beneficial to define custom scripts in your package.json. These scripts can handle tasks like building, testing, deploying, and versioning your package with simple commands.

8.1. Benefits of Custom Scripts

Automation: Reduce manual steps by automating build and deployment processes.
Consistency: Ensure that tasks are performed the same way every time.
Modularity: Create reusable scripts that can be combined for complex workflows.
Efficiency: Save time by chaining multiple commands into a single script.

8.2. Example: Deploying to Development and Production

Let's create two deployment scripts: deploy:dev for development environments and deploy:prod for production. These scripts will handle tasks such as building the project, tagging the Git repository, versioning, and deploying the package.

8.2.1. Defining the Scripts in `package.json`

Open your package.json and add the following scripts under the "scripts" section:

{
  "scripts": {
    "build": "tsc",
    "test": "jest",
    "version": "npm version patch",
    "tag:dev": "git tag -a v$(node -p \"require('./package.json').version\") -m \"Dev deployment v$(node -p \"require('./package.json').version\")\"",
    "deploy:dev": "npm run build && npm run test && npm run version && npm run tag:dev && git push && git push --tags && npm publish --tag dev",
    "tag:prod": "git tag -a v$(node -p \"require('./package.json').version\") -m \"Production deployment v$(node -p \"require('./package.json').version\")\"",
    "deploy:prod": "npm run build && npm run test && npm run version && npm run tag:prod && git push && git push --tags && npm publish"
  }
}

8.2.2. Breakdown of the Scripts

build: Compiles the TypeScript code into JavaScript using the TypeScript compiler.
test: Runs the Jest test suite to ensure your package is working correctly.
version: Increments the patch version in package.json following Semantic Versioning.
tag:dev / tag:prod: Creates a Git tag corresponding to the current version for development or production deployments.
deploy:dev:
1. Builds the project.
2. Tests the build.
3. Versions the package.
4. Tags the commit for a development deployment.
5. Pushes the commits and tags to the remote repository.
6. Publishes the package to npm with the dev tag.
deploy:prod: Similar to deploy:dev but publishes the package without a tag, making it the latest stable release.

8.3. Running the Deployment Scripts

With the scripts defined, deploying becomes straightforward:

Deploy to Development:

  npm run deploy:dev

This command will build your project, run tests, increment the patch version, create a Git tag, push changes, and publish the package with the dev tag.

Deploy to Production:

  npm run deploy:prod

This command performs the same steps as deploy:dev but publishes the package as the latest stable version without an additional tag.

8.4. Making Scripts Modular

By breaking down tasks into smaller, reusable scripts (like build, test, version, and tagging), you can compose complex workflows easily. This modularity allows you to maintain and update individual steps without affecting the entire deployment process.

For example, if you need to change how the project is built, you only need to update the build script without modifying the deployment scripts.

8.5. Additional Automation Tips

Pre/Post Hooks: Utilize npm's pre and post script hooks to run tasks automatically before or after specific scripts. For instance, you can add a prepublishOnly script to ensure tests pass before publishing.

  {
    "scripts": {
      "prepublishOnly": "npm run test && npm run build"
    }
  }

Environment Variables: Manage different environments (development, staging, production) by using environment variables within your scripts or leveraging packages like cross-env for cross-platform compatibility.
Error Handling: Incorporate error handling in your scripts to halt the process if a critical step fails, ensuring that incomplete or faulty deployments do not occur.

In Review

Publishing an NPM package may feel daunting, but the fundamentals are straightforward:

Initialize your project with npm init.
Write your code in either JavaScript or TypeScript (v5.7.2 recommended).
Add tests to ensure your package remains reliable.
Follow SemVer for version management.
Publish your package with npm publish.

By following these best practices you’ll have a package that is reliable, easy to maintain, and simple for others to consume. 💻

🚀 Tips for Every Level of Software Developer: How to Thrive in 2025

Forrester Terry — Sun, 05 Jan 2025 19:21:54 +0000

Sections

Introduction: Why 2025?
A.I. in 2025: A Quick Overview
Universal Core Principles
🌱 Level 1: Learning to Code (Associate/Intern/Beginner)
🎯 Level 2: Getting Your First Real Job/Gig (Junior Dev / Newbie Freelancer)
📈 Level 3: Growing as a Developer (Mid-Level), Taking on More Responsibility
⭐ Level 4: Becoming a Senior Developer, Leading Projects
🏗️ Level 5: Architect of Systems, Leading Teams (Principal Engineer / Architect / Tech Lead / Eng Manager)
👔 Level 6: Executive Roles (CTO / VP of Engineering / Director)
Personal Branding & Portfolio-Building Tips
Additional Tips for All Levels in 2025
Conclusion & Final Thoughts

Introduction: Why 2025?

📅 We’re standing at an interesting crossroads of A.I., quantum computing, robotics, and security, where each new year accelerates the possibilities in tech. In 2025, developers of all levels will face new challenges: fully remote teams in multiple time zones, code-generation tools that can produce entire modules automatically, microservices that require advanced orchestration, and a heightened focus on data privacy and ethics. All the while, the technologies and tools will becoming increasingly more capable and impactful.

Why read this?

This articles tries to break down practical tips by experience level, plus universal advice, so you can jump straight to what’s relevant for you—or get a sense of where you’re heading next in the world and career of software development. At minimum, hopefully you get some food for thought or validation of your current path.

A.I. in 2025: A Quick Overview

🤖 A.I. is not just for data scientists anymore. From Large Language Models (LLMs) assisting in code generation to computer vision for advanced robotics, A.I. seeps into every domain. Here’s what to watch:

AI-Assisted Code Review / Development Tools like GitHub’s built-in code analysis (powered by LLMs) can flag potential bugs or security issues automatically. Tools like Devin and Windsurf can write code for you.
Automated Testing Machine learning can identify edge cases you might never think of, generating test scenarios on the fly or even automating the testing process itself.
Computer Vision & Robotics Drones, automated factories, and self-driving systems are becoming more common, requiring devs who can integrate vision and language algorithms into everyday applications.
Personal “Agentic Systems” Think voice assistants or chat bots that understand context deeply enough to handle user queries or even carry out tasks in your dev environment via API calls or scripts.
More Capable Systems LLMs are becoming "smarter" and even smaller, allowing for more powerful tools to be built on top of them. Reasoning models such as o3 are reaching new benchmarks.

Suggestion: To leverage A.I. ethically—learn about model bias, data security, and compliance so you don’t ship harmful or vulnerable solutions.

Cool, Well and Good, but How Does This Affect Me?

There are a few key things here:

Opportunities: A.I. can automate repetitive tasks, freeing you up for more creative work. You can make entire one person businesses with the help of A.I.
Challenges: You need to understand how to work with A.I. tools, not just rely on them blindly. You need to know what their strengths and weaknesses are at this point.
Threats: A.I. can also be misused or introduce new security risks. It is also going to take jobs.

Either as a consumer, investor, or employee -- A.I. will affect you.

Universal Core Principles

💫 No matter where you are in your career, certain principles are golden:

Continuous Learning
- The tech world moves fast. Schedule weekly (or daily) “learning blocks” to stay ahead. Check out news, tutorials, or even a new language or framework.
Soft Skills & Communication
- Know how to articulate ideas, listen actively, and navigate conflicts. Emotional intelligence (EQ) is as critical as IQ.
Delivering Real Value
- Code that solves actual problems is always more valued than code that’s just “cool.”
Get Things Done
- Ship early, iterate often. Better to improve a shipped feature than over-engineer a never-released one.
- Focus on the must-do tasks first, then the nice-to-haves.
Security by Default
- Ransomware, data leaks, and compliance concerns (GDPR, CCPA, HIPAA) are not optional. Build security into your mindset from day one.
- Always think about how your code can be misused or exploited.
Burnout Is Real
- Set boundaries, take breaks, and safeguard your mental health. A sustainable pace beats sprints that end in exhaustion.
Networking & Collaboration
- The best opportunities often come through people — your next mentor, hiring manager, or co-founder might be at a local meetup or on Twitter/LinkedIn.

Level 1: Learning to Code (Associate/Intern/Beginner)

🌱 You’re dipping your toes in the water, whether it’s via a bootcamp, university, or self-study.

Key Goals

Master the Basics: syntax, data structures, OOP vs. functional, REST APIs, etc.
Hands-On Projects: build small things — try a tiny to-do app or a “guess the number” game.
Make Time to Practice: daily or weekly coding sessions to build muscle memory.

Brief Real-World Example:

Scenario: You’re a complete beginner learning Python. You want to automate some tedious file organization at work.

import os
import shutil

# A mini-script to move images to an 'images' folder and text files to a 'docs' folder
SOURCE_DIR = "/Users/username/Downloads"
IMAGE_DIR = "/Users/username/Downloads/images"
DOCS_DIR  = "/Users/username/Downloads/docs"

for file_name in os.listdir(SOURCE_DIR):
    if file_name.endswith('.png') or file_name.endswith('.jpg'):
        shutil.move(os.path.join(SOURCE_DIR, file_name), IMAGE_DIR)
    elif file_name.endswith('.txt') or file_name.endswith('.pdf'):
        shutil.move(os.path.join(SOURCE_DIR, file_name), DOCS_DIR)

You might fail a few times with path errors, but eventually, you get it working. You just automated something tangible, and that keeps you motivated!

Modern Dev Practices to Explore:

Git & GitHub: Basic version control is essential.
No-Code Tools: Zapier/Airtable to get a sense of what can be automated without writing everything from scratch. Combine with code via Webhooks or APIs.
Feature Flagging (Simple): Even at beginner level, toggling new features on/off in your small projects can teach you best practices early.

Key Takeaway (L1): Learn by doing. Don’t stress about perfection—celebrate small wins and keep pushing forward.

Level 2: Getting Your First Real Job/Gig (Junior Dev / Newbie Freelancer)

🎯 You’ve got some basics down, maybe a couple of small portfolio pieces. Now the big question: “How do I break in?”

Key Goals

Real-World Experience: internships, open-source projects, freelance gigs.
Understand the SDLC: planning, coding, testing, code review, deployment.
Learn Collaboration: communicating with team members, handling PR reviews, pair programming.

Example: The First Production Bug

Imagine you’re a junior developer on an e-commerce site. A user reports they can’t add items to the cart. It’s your first “on-call” rotation.

What Happened?

A small front-end validation script was recently changed. An unhandled null value breaks the cart function for certain user sessions.

How You Handled It

Checked error logs, used Chrome DevTools to replicate the issue, and asked a more senior dev to confirm your findings.
You pushed a quick fix, wrote a test case to prevent regressions, and documented it in the team Slack channel.

This real story (or a variation of it) happens daily in the dev world. Your ability to stay calm, troubleshoot effectively, and communicate is key.

Modern Dev Practices to Explore:

CI/CD: Tools like GitHub Actions or GitLab CI to automate testing and deployments.
Basic Infrastructure as Code (IaC): Even experimenting with Terraform or AWS CloudFormation for small setups.
A/B Testing & Feature Flags: Tools like LaunchDarkly let you deploy features to a small user subset first.

Key Takeaway (L2): Gaining real experience and handling production issues are how you really learn. Don’t fear failure; use it as a stepping stone.

Level 3: Growing as a Developer (Mid-Level), Taking on More Responsibility

📈 You can write code without constant supervision. You’re eager to learn more advanced concepts—maybe specialization or deeper system design.

Key Goals

Deepen Expertise: front-end frameworks, back-end architecture, data science, or security.
Work on Larger Projects: multi-service or multi-team efforts.
Mentor Juniors: share your knowledge, reinforce your own skills by teaching.

Core Modern Dev Practices:

Microservices Architecture
- Breaking monoliths into services. Familiarize yourself with Docker & Kubernetes.
Feature Flagging & A/B Testing
- Deploy new functionality to a subset of users and measure results with real metrics.
Edge Computing
- Offload certain tasks to the “edge” (CDN-level computations) to reduce latency for global users.

Level 3 Real-World Example: A/B Testing “Win”

Scenario

Your mid-level dev team wants to improve the checkout funnel for a SaaS product. You set up an A/B test using LaunchDarkly (or a similar tool) where half of your traffic sees a new checkout UI and half sees the old.

Process:

Hypothesis: The new UI is cleaner and reduces friction, leading to higher conversions.
Implementation: You hide the new checkout behind a feature flag, rolling it out to 10% of users initially.
Analysis: After 2 weeks, the new UI shows a 7% lift in conversion.
Decision: You roll it out to 100%, monitor logs for issues, and measure again.

Result: A safe, data-driven approach to improving a core business metric. You’ve demonstrated not just coding skills, but also product thinking.

Level 4: Becoming a Senior Developer, Leading Projects

⭐ Now you’re the go-to person for technical decisions, mentoring other devs, and owning entire project life cycles.

Key Goals

Big Picture Awareness: how your code fits into revenue goals, user experience, compliance, etc.
Lead & Delegate: assign tasks, trust your team, handle tough problems.
Advanced Security & Reliability: from secure coding to robust logging & monitoring (SRE mindset).

A Quick Snippet: Senior Dev Do’s and Don’ts

// DO: Write self-explanatory, properly commented/documented, maintainable code
function calculateCartTotal(items) {
  // items = array of { price, quantity }
  return items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
}

// DON'T: Obfuscate logic or rely on "clever" hacks, no clear naming convention or comments for intent.
function cCT(i){let s=0;for(let x in i){s+=i[x].p*i[x].q;}return s;}

Do: Name variables and functions clearly, handle edge cases, add comments for tricky parts.
Don’t: Write “clever” code that only you can understand.

Modern Dev Practices

Observability: Tools like Datadog, Grafana, or Prometheus to track system performance in real time.
Ethical Hacking & Pen Testing: Ensuring your apps are resilient against malicious attacks.

Key Takeaway (L4): Balance being hands-on with letting your team learn and fail productively. Own projects, keep an eye on security, quality, and business impact.

Level 5: Architect of Systems, Leading Teams (Principal Engineer / Architect / Tech Lead / Eng Manager)

🏗️ At this level, you’re shaping long-term technical strategy and building cohesive, scalable systems. You also spend more ( A LOT MORE ) time developing people than writing code.

Key Goals

Drive Strategy: Align technical road maps with business objectives.
Develop & Empower Teams: Mentorship, career growth plans, and performance feedback.
Optimize Processes: Introduce coding standards, define architecture patterns, evaluate new tooling.

Modern Dev Practices

Infrastructure as Code (IaC)
- Terraform, AWS CDK, or Azure Resource Manager to manage large infrastructures predictably.
Continuous Deployment
- Pipelines that auto-deploy to production with safe rollbacks.
Data Privacy & Compliance
- Ensuring your architecture respects GDPR, HIPAA, or industry-specific regulations.
- Not getting hacked or leaking data is a big deal... a really big deal.

Key Takeaway (L5): Your effectiveness is measured not by the lines of code you commit, but by how well the system and the team function under your guidance.

Level 6: Executive Roles (CTO / VP of Engineering / Director)

👔 You’re making decisions on technology, culture, and strategic direction that directly affect the company. Your role is less about coding and more about vision, team-building, and business outcomes.

Key Goals

Align Tech & Business Strategy: Forecast trends, evaluate big bets on AI, automation, or expansion.
Lead Culture: Attract top talent, retain them with a positive environment, and champion diversity and inclusion.
Manage Stakeholders: Communicate with board members, investors, and other executives; remove roadblocks for your teams.

Example: Handling a Major Pivot

Scenario: The market for your main product is shrinking; your competitor is using advanced AI personalization. You must decide whether to pivot the entire dev team to adopt new AI-based features or maintain your existing stack.
Process: Evaluate ROI, gather input from principal engineers, run small proofs-of-concept, and present findings to the board.
Outcome: If the POC shows promise, you shift resources, re-train your engineers, and ensure a stable migration strategy over the next 6–12 months.

Key Takeaway (L6): You’re the bridge between tech possibilities and business realities. vision, leadership, and the ability to make tough calls define you at this level.

Personal Branding & Portfolio-Building Tips

🎨 Whether you’re Level 1 or Level 6, personal branding can amplify your opportunities:

Platform Recommendations
- Dev.to: Great for sharing tutorials or insights.
- GitHub: Keep your portfolio public, showcase open-source contributions.
- LinkedIn: Maintain an up-to-date profile, share thought leadership posts.
- Twitter / X: Quick takes on industry trends, real-time networking.
- YouTube / Twitch: Live coding sessions, tech discussions.
- Reddit: Sharing projects and getting... all types of feedback!
Content Creation
- Write short articles on frameworks like Quasar, Firebase, or TypeScript tips.
- Make short videos explaining how you used CrewAI (a hypothetical AI tool) for automated code reviews.
- Show “before and after” examples of your code or architecture improvements.
- Focus on niche topics that you are passionate about or deal directly with to avoid competition in over-saturated areas.
Building a Developer Portfolio
- Include 2–5 representative projects (not 20 half-done ones).
- Clearly define: the problem, your solution, and impact (metrics or user testimonials).
- Use short videos or animated GIFs to demo features.

Pro Tip: Even senior-level folks benefit from a personal portfolio to demonstrate technical leadership, architectural diagrams, or big wins.

Additional Tips for All Levels in 2025

💡 Infrastructure as Code: Reduces manual errors, improves reproducibility.

💡 Feature Flagging, A/B Testing, Edge Computing: Helps you deploy features safely and measure real impact at scale.

💡 Stay Abreast of AI Tools: Large Language Models, Computer Vision frameworks, and Automated Testing are evolving. Keep exploring new ones that align with your domain.

💡 Emphasize Security and Privacy: DevSecOps is not optional. Integrate security scanning into your CI/CD pipeline.

💡 Interdisciplinary Knowledge: Understanding product management, UX design, or data science can make you a more strategic dev.

💡 Work-Life Integration: Remote/hybrid setups can blur boundaries. Create a routine that keeps you effective and sane.

💡 Sometimes You Need to Say NO: Over-committing leads to burnout. Learn to set boundaries and prioritize effectively.

My Personal Path

For myself, I started out as a computer repair technician. I never actually thought I would program because it seemed really difficult. On the job, I started to learn how to create small scripts and tools that helped my desktop support team. I got a chance to do more development, and from there learned new things project by project. I went from Software Developer to Lead Developer to an Engineering Manager.

My focus for the future is to become a subject matter expert on automating tasks and workflows with A.I., as well learning more about Web3 tools. There seems like there is going to be a lot of demand from businesses to automate more and more tasks, and I want to be a part of that.

My career path was made possible by hard work, but vey much also by the help of mentors and peers who helped me along the way. Just as importantly, I took things one day at a time and tried to have fun along the way.

Final Thoughts

🎬 Whether you’re writing your first “Hello World” or planning a multi-year AI roadmap at the C-suite level, 2025 offers vast opportunities. The key to thriving is:

Continuous Learning & Adaptability
Focus on Real-World Value
Collaboration & Empathy
Security & Ethical Responsibility

Each level demands new skills and perspectives — but they all build on the same foundations of consistent learning, delivering value, and fostering strong relationships. Share your progress, connect with mentors, and keep exploring emerging tools—from LLM-driven code reviews to microservices on the edge.

Action-able Idea:

Pick one tip relevant to your level and apply it this week—whether it’s setting up a mini CI/CD pipeline, writing a Dev.to post, or scheduling a 1:1 with a teammate to discuss career growth.

Thanks for taking the time to read this. Hopefully you found something useful here. If you have any questions or want to share your own career journey, feel free to comment below. I have a lot more to say about each level and some lessons learned, so I may make a series diving into each level more.

Remember, the journey is as important as the destination. Enjoy the ride! Everything builds on top of each other, the wins and the misses.

Happy Programming! And Happy New Year! 🎉

Building an App with AI Pair Programming: Lessons from a 7-Hour Sprint

Forrester Terry — Thu, 26 Dec 2024 13:40:10 +0000

As developers, we're always looking for ways to improve our productivity and streamline our workflows. With the recent advances in AI (and my firm belief that these technologies will be game-changing), I decided to put these tools to the test in a real-world development scenario.

My Goal: Build a full-stack AI-powered food tracking app PoC in just 7 hours.
The Result: It worked pretty well! But not without challenges.

Here's what I learned about using AI as a development buddy.

The Project

The goal was ambitious but focused: create a mobile app that lets users photograph their food and automatically log it to a food tracker using AI recognition. The tech stack included my go-to's: Quasar Framework (VueJS Framework), Google Firebase, and Capacitor (Mobile Dev Framework), with Google Gemini 2.0 Flash for AI inference.

Nothing super fancy, but more than enough complexity to put AI assistance to the test.

The A.I. Tools

I used a combination of AI tools to assist with different aspects of the project:

ChatGPT (o1 Model): For high-level planning, requirements gathering, and general guidance
Claude 3.5 Sonnet via WindSurf/Cascade: For code generation and specific development tasks, I used a tool called WindSurf by Codeium. It is essentially an IDE built off Visual Studio Code with an A.I. code writer built in. It has direct access to files, and can quickly write and edit entire files with version control.
Google Gemini 2.0 Flash: For image recognition and food classification. This model is super powerful and super cheap.

The "AI as Dev Intern" Approach

One of the most valuable insights I gained was thinking of AI as a junior developer or intern. This mental model completely changed how I approached the collaboration. Just as you wouldn't dump an entire project on a new intern's desk and expect perfect results, I learned to:

Be explicit with instructions
Break tasks into manageable chunks
Review output and provide feedback
Not expect too much at once
Give guidance and direction when needed

This approach led to better payoff, and worked better than treating the AI as either "all-knowing" or "completely unreliable".

What Worked Well

Planning and Requirements

AI proved exceptionally helpful in the planning phase. I started with a rough project outline and used iterative prompts to refine it. For example, one of my initial prompts was:

Can you help me plan out making the following app in 7 hours:

<information about the app>

Detail out how long I should spend on each section, 
and revise my overall plan as needed.

This sparked a back-and-forth that helped crystallize the project scope and timeline, leading to a more realistic and detailed plan.

Documentation

The AI tools excelled at generating and maintaining documentation. It could quickly create comprehensive markdown files and keep them updated as the project evolved. This freed up valuable time for actual development work.

Iterative Development

Breaking down development into smaller, focused prompts proved highly effective. Instead of trying to generate entire components at once, I used a cascade of prompts, each building on the previous one. For example:

First, setting up Firebase backend infrastructure
Then, building the frontend boilerplate
Following with specific features like the camera capture screen
Finally, adding data processing and display functionality

A neat trick I found, was to have the A.I. keep notes of the progress and next steps, so it could have something to reference in between prompts. Since I was using WindSurf, I could use a "master prompt" to keep the conversation going. The master prompt would instruct the A.I. to refer back to the notes and add to them as it goes along writing code.

Bug Fixes and Post Development

Another place where WindSurf shined was in bug fixes and post-development tasks.

After testing my app out and noting some bugs, I passed my list to WindSurf and it could quickly identify and correct issues, and even generate test cases to ensure the fixes worked. This saved me a ton of time and effort.

I had the following list of bugs, and only on a few occasions did I have to manually fix them:

x = Was fixed by AI
- = Was fixed by me, assisted by AI
* = Was not fixed by AI, I had to fix it myself

[x] BUG> Camera goes blank after taking picture and hitting cancel (Web implementation)
[x] BUG> In the Detected Foods View If no foods are detected, list is blank, which is good, but we should show some sort of icon and text to explain that no foods have been added or detected
[x] BUG> In the Detected Foods View, it would be nice to add each Item (text title, confidence, delete button, select matching food drop down) better grouped to make it clear that all those elements are a part of the same food detection. This can be done via a q-card, some better styling, or whatever
[ * ] BUG> In the Detected Foods View, Select Matching food drop down does not reopen properly when attempting to open drop down for something added solely via search (rather than an item added via the camera)
[x] BUG> In the Detected Foods View, Cancel button should return user to Dashboard debounceSearch should not fire if input is empty
[-] FEATURE> Entry Submission (Backend) - Take IMG, and resize, crop, compress, etc to make the image fit nicely in a 128*128 square nicely. Create multiple sizes for image, and add links to images in the record for submission (along side imageUrl)
[x] FEATURE> Dashboard - Show IMG for each captured meal entry, loading appropriate size
[x] FEATURE> Add View Meal Page -> show all details and charts and stuff
[x] FEATURE> Add Edit Meal Functionality -> Bring back modal from Camera page view, but only use the modal. Do not start camera.
[x] FEATURE> Add Delete Meal Functionality
[x] FEATURE> History View Meals: Ability to view ALL MEAL entries, paginated, by day. Use Quasar Timeline -> have Meals button in menu goto this page. This page should show the same type of cards shown for meal entries on the IndexPage.vue
[x] FEATURE> History View Water: Ability to view ALL WATER entries, paginated, by day, Use Quasar timeline -> have Water button in menu goto this page. This page should show the same type of cards shown for water entries on the IndexPage.vue
[x] BUG> Water history Edit does not work
[x] BUG> Water history data is weird

Challenges and Gotchas

Not everything was smooth sailing. Some key challenges emerged:

File Editing Issues

I discovered several limitations when it came to file modifications:

Open files sometimes got seemingly locked / became uneditable by WindSurf
Longer conversations absolutely decreased the quality of code editing

NOTE: As of writing this, it seems the file lock/failed filed editing bug has been fixed in the latest version of WindSurf.

Context Management

The quality of AI assistance degraded in longer conversations. I learned to start fresh conversations for new components and provide condensed context rather than trying to maintain one long session.

As the code got longer and more complex, the AI struggled to keep up. I had to break down the tasks into smaller, more manageable chunks to maintain quality, or had to provide lots of details and context to keep the AI on track.

Going off track would entail dropping features, erasing relevant code, or sometimes building the wrong thing entirely. This was a big time sink, and I had to be very careful to keep the AI on track or decide to code manually.

Knowing When to Code Manually

Sometimes, doing it yourself is simply faster. Learning to recognize these moments saved considerable time and frustration. As noted in my development log: "When it works, it works well. When it doesn't, it can be a time sink."

Best Practices That Emerged

Git Commit Frequently: Before having AI make significant changes, commit your current state. This provides an easy fallback if things go wrong.
Prepare Boilerplate Code: Set up your project structure and basic configurations before engaging AI assistance. In my case, this meant:
- Setting up Quasar/Vue CLI
- Configuring Firebase CLI and components
- Establishing basic project structure
Clear and Detailed Prompting: Be as specific as possible with your requirements. Include relevant context and examples. Spend as much time as you can in your requirements and design phase, and provide as much detail as possible. These notes and direction will not only help you execute on your project better, but it drastically improves the quality of the code generated by the AI.
Iterative Feedback: Don't hesitate to correct or guide the AI. For example, when I received output that didn't quite match requirements, I provided specific feedback:

That works pretty well, except a few things aren't working:
1. When I go to the home page (/) I get a blank screen
2. The Dashboard summary view doesn't show macro nutrient information
3. The water should be in cups

This kind of specific feedback usually led to quick, accurate corrections.

The Verdict

Using AI absolutely accelerated development. While it required guidance and occasional correction, the combination of ChatGPT and Claude along with WindSurf allowed me to progress much further than I could have alone in the same time frame.

That said, success required understanding both the capabilities and limitations of these tools. The key was finding the right balance between AI assistance and human expertise, using each where they excel.

Looking Forward

This experiment suggests a future where AI tools become an integral part of the development workflow - for now, not replacing developers, but augmenting their capabilities. The key is learning to work with these tools effectively, understanding their strengths and limitations, and developing workflows that maximize their benefits while minimizing their drawbacks.

For developers interested in incorporating AI into their workflow, I recommend starting small, establishing clear patterns of interaction, and gradually expanding AI's role as you become more comfortable with its capabilities and limitations.

The tools are at the level of a junior developer, and soon with enough training data and iteration, they will be able to do much more. I can see these tools ultimately writing entire applications and handling the majority of the development process. Until the models can simulate a senior developer, we will still need human oversight and guidance.

Strengths:

Documentation: Generating and maintaining documentation
Minor Bug Fixes / Troubleshooting: Identifying and correcting bugs
Unit Testing: Generating test cases and ensuring code quality
Code Generation / Small Components: Writing boilerplate code and basic components to get you started
Planning and Requirements Gathering: Outlining project scope and timeline
Infrastructure Setup: Configuring basic project structure and setup, with Terraform, Dockerfiles, etc.
Rapid Learning and Prototype Generation: Quickly learning new frameworks and generating prototypes

Weaknesses:

Complex Logic: Handling intricate business logic or complex algorithms
Design and UX: Creating visually appealing interfaces or user experiences
Writing Larger Components: Writing complex modules or larger components end to end
Context / Memory: Maintaining context over long conversations or across multiple components
Complex Debugging: Troubleshooting complex issues or edge cases, often requires guidance to be useful
Up to Date with Latest Tech: Keeping up with the latest frameworks, libraries, and best practices

I'm excited to see where this technology goes and how it will shape the future of software development.

The Pictures!!!

Here are some quick screenshots of the app I was able to build in 7 hours. It's not perfect, but it's a solid start!

(Using Camera to Capture Food)

(Sending Image to AI for Food Recognition)

(Viewing Results - Adding Food to Tracker)

(Confirming Food Entry)

(Dashboard View)

(Food Entry View)

Shameless, But Relevant Plug:

While I am still working on the food app mentioned in this post, I was able to finish another project quite quickly using WindSurf and A.I.

If you're interested in an AI-powered Git CLI helper to make commit messages and release notes easier to maintain, check out eGit

Building A.I. Based Apps : A General Approach

Forrester Terry — Sun, 14 Jul 2024 20:19:31 +0000

In today's rapidly evolving tech landscape, developing applications powered by generative AI models, particularly Large Language Models (LLMs), has become an exciting frontier and a golden opportunity. LLMs are advanced AI systems trained on vast amounts of text data, capable of understanding and generating human-like text. They're the powerhouse behind many cutting-edge AI applications, from chatbots to content generators.

As someone currently working on several AI apps, I've realized that having a structured process and understanding the common phases of AI application development can significantly boost your chances of success. This high-level guide details the order of operations and general steps involved in creating AI-powered applications.

The AI Application Development Lifecycle: An Overview

My approach consists of five main phases: Input, Process, Quality Assurance, Deployment, and Output. Each phase plays a crucial role in creating a successful AI application. These stages are interconnected, forming a cycle of continuous improvement and refinement.

Let's dive into each phase, exploring key components, pro tips, and common challenges. To illustrate these concepts, we'll use a running example of building an AI-powered content recommendation system for a news website.

Step 1: Input (The Challenge)

The journey begins with defining your challenge (the problem you're trying to solve) and gathering the relevant data.

Key Components:

Data Collection: Identify and gather relevant data sources. This could include text corpora, databases, APIs, or web scraping. The key is to ensure your data is comprehensive and representative of the problem you're trying to solve.
Data Preparation: Clean, format, and preprocess your data. This step is crucial for ensuring the quality of your model's input. Consider techniques like normalization, tokenization, and handling missing values.

Pro Tip: Pay attention to data quality and potential biases at this stage. Your model is only as good as the data it's trained on.

Common Pitfall: Overlooking data privacy and compliance issues. Always ensure you have the right to use the data you've collected.

Example: For our content recommendation system, we'd collect article data, user reading history, and engagement metrics from the news website's database.

Exercise: Identify three potential data sources for your AI project. For each source, list possible challenges in data collection and preparation.

Step 2: Process (Secret Sauce)

This is where the magic happens. You'll select and fine-tune your model, implement RAG, and develop your prompts or code.

Key Components:

Model Selection: Choose the right LLM for your task. Consider factors like model size, specialization, and deployment requirements. Don't always go for the largest model – sometimes a smaller, more specialized model can outperform larger ones for specific tasks.
Fine-tuning: Adapt the chosen model to your specific use case using domain-specific data. This can significantly improve performance on your particular task.
RAG Implementation: Implement Retrieval-Augmented Generation to enhance your model's knowledge and reduce hallucinations. This is particularly useful for tasks requiring up-to-date or specialized information.
Prompts/Code Development: Craft effective prompts or develop code to interact with your model and process its outputs. Experiment with different prompt structures to find what works best for your use case.

Pro Tip: Keep a versioning system for your models and prompts. This will help you track changes and revert if necessary.

Common Pitfall: Overfitting the model to your training data, leading to poor generalization.

Example: For our recommendation system, we might choose a medium-sized LLM and fine-tune it on our news articles. We'd implement RAG to retrieve relevant article information and develop prompts that generate personalized recommendations.

Exercise: Research three different LLMs that could be suitable for your project. Compare their strengths and weaknesses.

Step 3: Quality Assurance (The Validation)

Before deployment, it's crucial to validate and refine your model's performance.

Key Components:

Output Validation: Verify the accuracy, relevance, and safety of your model's outputs. Use a diverse set of test cases to ensure robust performance.
Scalability Testing: Assess your application's performance under various loads and conditions. This helps identify potential bottlenecks before they become real-world problems.
Feedback Loop: Implement mechanisms to continuously improve your application based on validation results and testing outcomes. This could involve automated systems or human-in-the-loop processes.

Pro Tip: Don't skip this step! It's easier and cheaper to fix issues now than after deployment.

Common Pitfall: Not testing for edge cases or unexpected inputs, leading to vulnerabilities in the live system.

Example: We'd test our recommendation system with a variety of user profiles and article types, ensuring it provides relevant recommendations across different scenarios. We'd also simulate high traffic to test scalability.

Exercise: Design a test plan for your AI application. Include at least five different test cases that cover various aspects of your system's performance.

Step 4: Deployment

This phase focuses on getting your AI application ready for real-world use.

Key Components:

Infrastructure Setup: Choose and configure the right infrastructure for your application. This could involve cloud services, on-premises solutions, or a hybrid approach.
Security Implementation: Ensure your application is secure. This includes data encryption, access controls, and compliance with relevant regulations (e.g., GDPR, HIPAA).
Performance Monitoring: Set up systems to monitor your application's performance in real-time. This allows you to quickly identify and address any issues that arise.

Pro Tip: Consider a phased rollout to minimize risks and gather real-world feedback gradually.

Common Pitfall: Underestimating the computational resources required for your AI application, leading to performance issues.

Example: We might deploy our recommendation system on a cloud platform, implementing strict data protection measures. We'd set up monitoring dashboards to track recommendation accuracy and system performance.

Exercise: Outline a deployment plan for your AI application. Include considerations for scaling, security, and monitoring.

Step 5: Output (The Business Value)

This final phase is where your AI application delivers tangible results.

Key Components:

Content Generation: Produce text, summaries, translations, or other forms of content that add value to your users or business processes.
Decision Support: Develop systems that assist in decision-making processes, providing insights and recommendations based on data analysis.
Process Automation: Create workflows that automate repetitive tasks or entire business processes, increasing efficiency and reducing errors.

Pro Tip: Regularly assess the business impact of your AI application. Are you meeting the initial objectives? Are there unexpected benefits or challenges?

Common Pitfall: Focusing too much on technical metrics and losing sight of real-world impact and user satisfaction.

Example: Our recommendation system would provide personalized article suggestions to users, potentially increasing engagement and time spent on the news website.

Exercise: Define three key performance indicators (KPIs) for your AI application. How will you measure its success in delivering business value?

Resources for AI Application Development

To help you on your journey of building AI-powered applications, here's a curated list of tools, services, and frameworks that can be invaluable at various stages of development. These resources are grouped by development phase to align with the structure of this guide.

How to Use This Resource List

This list is not exhaustive, but it provides a solid starting point for each phase of your AI application development journey. Start with the tools that align with your current phase and gradually explore others as your project evolves. Remember, the best tools for your project will depend on your specific requirements, team expertise, and scalability needs.

Input Phase

Data Collection and Preparation:
- Apache Spark: Powerful engine for large-scale data processing
- Pandas: Python library for data manipulation and analysis

Process Phase

Development Frameworks:
- Quasar Framework (Vue.js): Perfect for cross-platform development
- React Native: Popular for cross-platform mobile app development
- Flutter: Google's UI toolkit for natively compiled applications
Model Development and Training:
- PyTorch: Open source machine learning framework
- TensorFlow: Google's open-source platform for machine learning
LLM Testing and Deployment:
- OLLAMA: Great for quick LLM testing and experimentation
- Hugging Face: Platform for sharing, discovering, and experimenting with ML models

Quality Assurance Phase

Testing and Monitoring:
- Prometheus: Monitoring system and time series database
- Grafana: Analytics and interactive visualization web application

Deployment Phase

Infrastructure and Backend:
- Firebase: Comprehensive platform for building web and mobile applications
- AWS Amplify: Full stack development platform from Amazon
- Google Cloud Platform: Offers a wide range of services including AI and ML tools
LLM Optimization and Deployment:
- TensorRT: NVIDIA's SDK for high-performance deep learning inference
- Google Vertex AI: End-to-end platform for deploying ML models at scale

Output Phase

API Development:
- FastAPI: Modern, fast Python web framework for building APIs
- Express.js: Minimal and flexible Node.js web application framework

Cross-Phase Tools

Version Control and Collaboration:
- GitHub: Platform for version control and collaborative development
- DVC (Data Version Control): Version control system for machine learning projects

Conclusion

Building AI applications with LLMs is an iterative process. As you progress through each phase, you'll likely find yourself cycling back, especially between Process and Quality Assurance, to refine and improve your application.

Key takeaways from each step:

Input: Focus on data quality and representativeness
Process: Choose the right model and fine-tune effectively
Quality Assurance: Test thoroughly and implement feedback mechanisms
Deployment: Prioritize security and scalability
Output: Align with business objectives and measure real-world impact

Remember, the key to success lies in continuous learning, experimentation, and adaptation. Start small, iterate quickly, and always keep your end users in mind. The field of AI is rapidly evolving, so stay curious and keep exploring new techniques and tools.

Your journey in AI development starts now – what will you build?

Next Steps:

Define your AI application concept
Identify your data sources
Choose your initial tech stack from the resources list
Start prototyping!

Would be very interested to hear about other's experiences building applications around A.I. tooling, please feel free to comment with any stories, questions, or thoughts.

Happy developing, everyone!

Building RoboPoll: A Journey with A.I., Quasar, and TypeScript

Forrester Terry — Mon, 15 Jan 2024 00:23:35 +0000

Introduction

I recently built a website using Quasar and Firebase and thought it would be fun to share what the process was like at a high level. The goal was to build an MVP version of the project and build it rapidly.

This was my journey with RoboPoll, a ‘simple’ website that combines fun with data. RoboPoll is designed to engage users with AI-generated summaries of news and a variety of topics.

About Me:
I have about 6 years of experience and am self taught. I’m familiar primarily with JavaScript and Python.

The Requirements and Design

This is how I planned out my work:

1) Initial Concept and PoC: To play around with some ideas, I made a very simple PoC. I decided what I wanted to build and just slapped it together. As days progressed, I found flaws and considerations to note down. This PoC wasn't about adding components or making anything super stable, but about shaping the core identity of the app and figuring out what I wanted to build ultimately.

2) Requirements: I began defining the app's requirements, carefully selecting features for the initial release (MVP) and planning subsequent versions. This approach prevented overwhelming myself with too many features at once. I cannot stress enough, start with your requirements/design and really understand what you want/need to build before you seriously start putting down code.

3) Design, Workflow and Wireframes: Before diving into coding, I focused on the app's basic layout and feel. I drafted wireframes and detailed out workflows as step-by-step lists, ensuring a clear understanding of the functionalities needed. This stage was crucial in visualizing the end product and planning the implementation steps. It also helped me find anything I missed during requirements gathering.

4) High-Level Planning / Code Design: The app's components included a frontend website, AI automation running on a separate machine, and Firebase as the backend. I drew flow charts to map out how these components interacted, providing a clear picture of the app’s infrastructure. At this point, I also figured out what under-the-hood code I would likely need for both the backend and web application. This typically involved detailing out various modules and potential functions with examples of the data being processed or passed.

Choosing the Tech Stack

My suggestions with picking a tech stack for a project:

make sure it works for what you need
make sure it works well in general and is supported
make sure you are comfortable with it.

If all three are true, then it is suitable.

My selected tech stack was:

TypeScript
Quasar Framework (VueJS)
NodeJS (for automation tools)
Ollama for LLM management and API
Docker (for containerizing my backend apps - incase I want to them to the cloud)
Firebase (backend cloud infrastructure - Firestore, Hosting, Storage, Authentication, Algolia plugin)

Reasons for Some of These Tech Choices:

LLMs and Testing: The concept of AI generating content was intriguing. I wanted to explore how to integrate LLMs into a service effectively. My hardware setup, consisting of one RTX 3060 and one RTX 3050 GPU, was suitable for running inference with 7B and 13B parameter models. I used Ollama to manage the deployment of the LLM due to the simplicity and nice out of the box configurations. Since the LLM does not need to be interacted with in real time, I chose to pick something off the shelf and simple.

Quasar Framework/VueJS: My familiarity with Vue and the availability Quasar is why I chose Vue. Quasar offers cross-platform development ease, bringing together UI components and essential tools.

Ollama: It simplified LLM management, allowing me to focus more on application development rather than the nuances of model management.

Docker: Provided flexibility for backend automation, making it easy to shift operations between machines. Ollama is also offered as a Docker image, so this made bundling my backend app, and the Ollama runtime together easy.

Firebase: Offers a robust and scalable backend solution, especially valuable for its cloud functions. They offer a free tier, which actually met most of my needs. I ultimately went with a Pay-As-You-Go plan for the deployment.

TypeScript: For a project of this scale, TypeScript's ability to define objects and return types is invaluable. It enhances organization and bug detection. This became very beneficial during refactors of code.

Development: Challenges and Solutions

Going through this project, there were a few things that I had to deal with:

Development Fatigue and Keeping Organized: Managing workload and staying motivated was a challenge. Utilizing project management tools like Jira helped me maintain focus. Taking breaks when needed and tackling tasks one at a time kept the project manageable. When I would hit a brick wall, I would step away from the problem and return to it the next day.

LLM Accuracy and Speed: I employed multiple prompts to refine content quality. Testing different LLM models led me to choose dolphin-mistrial for its performance. Regularly adjusting LLM settings and prompts was key to achieving the desired output quality. I also tracked the performance and quality of output across different configurations to find the best one.

App Complexity and Performance: Balancing performance and complexity was important. I used Firebase for atomic transactions to ensure accuracy and scalability in features like the voting system. TypeScript played a significant role in managing the complexity, aiding in a modular and organized code structure so refactoring could be possible. For anything I was unsure about, I checked on Google and used ChatGPT.

UX Focus: User experience was paramount. I conducted testing with friends and family, which was invaluable. Their feedback drove many refinements, particularly in navigation and intuitive design. The focus on key features that users cared most about was essential in making the app more engaging.

Security: I made sure to spend extra time focusing on secure implementations. Data sanitization and functionality abstraction via Cloud Functions was implemented. I also tried using a tool called ZAP to do penetration and fuzz testing. Firestore and Firebase storage rules are used to prevent unauthorized access to data.

Feature/Component Notes

Polls and News Sections: This was the heart of the app. The journey began here, with content populated through AI automation. Gradually, this section shaped the overall structure of the frontend.

User Authentication: Implemented smoothly with Firebase Authentication, enhancing user security and experience.

Comments, Save/Bookmark, Share Functionality: Building a robust commenting system was a complex task. It involved user association, scalable comment loading, and an intuitive UI. Youtube comments were used as inspiration.

Basic Analytics and SEO: Integration of Google Analytics provided insights into user behaviors, crucial for future enhancements.

Bug Reporting System: This feedback loop is vital for continuous improvement and user engagement.

Letting Users Add Polls to the Queue: A critical feature that underwent several iterations to ensure user engagement and interest.

Learning, Reflections, Next Steps

This project was a fun one. It taught me the importance of scalability, organization, and user-focused development. Docker and Firestore's advanced features were key learnings. Sharing the app and opening up to feedback, though initially daunting, proved to be incredibly valuable.

Additionally, using ChatGPT to brainstorm on implementation approaches and help with generating dummy data worked very well. For design inspiration, I looked at similar sites or sites with similar features to get a starting point.

I opted not to write unit tests for this app, but highly suggest carefully selected unit tests for anything really serious.

I'm now at a stage where user feedback will shape the app's future. My immediate goal is to gather insights from actual users and refine the app based on their experiences and suggestions. Things are very basic right now, and it would be great to learn more about what actual users care about.

Conclusion

Building the app has been filled with fun, challenges, and continuous learning. It's been rewarding to see it come together and to explore the potential of LLMs in a real-world application.

The site likely has a lot of bugs, and at this point in the process the next focus would be lots of end to end testing and bug fixes. The summaries and LLM automations still need to be fine tuned as well.

I invite you to check out RoboPoll though and let me know if you have any questions or feedback.

Thank you for joining me on this adventure. Let me know your thoughts or opinions on finishing and structuring personal projects.

Some Quick Resources:

Ollama - used for running LLMs on my machine
OpenInterpreter - a neat project which allows you to run a ChatGPT like code environment on your own machine.
Quasar Framework - VueJS framework for making web, mobile, and desktop apps.
Wikipedia API - Used to give the LLM data
News API | NewsData.io - API used to collect news

Idea: Using Decentralized Identities to Fight AI Threats and Shape Internet 3.0

Forrester Terry — Thu, 30 Mar 2023 04:47:10 +0000

With the rapid advancement of AI technologies, we will see an increase in internet threats and exploitations. I've been thinking about the future of the internet and how we can make it more secure, decentralized, and user-focused while mitigating the negative effects of AI.

I thought of an idea where we could use Hyperledger Indy for decentralized identity (DID) management and basically create a new protocol that requires DIDs for auth. This is an extension of another idea I had around DIDs and blockchains.

I'd love to get your thoughts and feedback on this, or if you know if any other ideas like this being explored!

The Idea:

Create a new version of the hypertext transfer protocol that requires users to have a DID, managed through Hyperledger Indy. This DID would be checked for validity before allowing any transaction to go through, essentially creating a more secure and decentralized internet (Internet 3.0).

How It Addresses AI-driven Threats:

It hinders AI-generated phishing attacks, as every request would require a valid DID.
It thwarts AI-powered bots and fake accounts, as the DID requirement would make it challenging to create and maintain large-scale automated systems for malicious purposes.
It makes A.I generated or altered content more traceable, as content creators and distributors would have associated DIDs, promoting accountability and authenticity. This could be paired with hashing content for tracking.

Perceived Strengths:

Enhanced security and privacy through a robust PKI, selective disclosure, and zero-knowledge proofs.
Decentralized and user-centric architecture.
Greater interoperability and ease of integration with other web3 technologies.
Encourages trust through transparent and tamper-proof DID management.

Foreseeable Weaknesses/Challenges:

Increased complexity for developers and users.
Potential performance trade-offs due to the computational overhead of DID validation and zero-knowledge proofs.
Adoption (browser vendors, web service providers, etc.).
Scalability
Educating users and businesses about the benefits and workings of the new protocol.

Opportunities:

Reduces reliance on centralized certificate authorities.
Empowers users with more control over their data and identity.
Fosters a more open and equitable internet ecosystem.
Encourages the development of new web3 applications and services prioritizing security, privacy, and user empowerment.

So, what do you all think? Are there any major concerns or potential improvements I've missed? What do you think about the items I've outlined already?

I'd love to hear your thoughts, especially if you have experience with Hyperledger Indy, DIDs, or web3 technologies!

DEV Community: Forrester Terry

Your AI Coder Will Go Rogue If You Let It (Here's Some Tips to Stay in Control)

Lessons from Building with AI Coding Assistants

Challenge It When It Changes Your Approach

The Websocket Ambush

The "Write Scripts to Disk" Thing

Tell It to Do Its Own Testing

The Bad Command Loop

Sometimes You Need Research, Not Code

Using Another AI to Unblock the First One

AI-Generated Deployment Scripts (Carefully!)

Terraform Became My Friend

The Giant Caveat

Always Review, Always Ask Why

Wrapping Up

A.I. — The Amplifier: From Software Developer to Software Creator 🚀

What I'm Seeing Out There 📊

❓ "Should I Still Learn Software Development?"

What I've Learned About A.I. Capabilities

The Real Productivity Numbers (They're Messier Than You Think)

🛠️ What Should You Actually Learn?

Start With the Foundations

Then Build Your Stack

Level Up When You're Ready

💼 "How Do I Get a Job?"

If You're Starting from Zero

If You're Mid-Level or Beyond

🎮 How I Got Started with A.I.

⚠️ Real Talk: What's Coming

What About "The Next Big Thing"?

🎯 The Bottom Line

I Have Bipolar II and I'm a Software Engineering Manager. Here's What Actually Works.

The Real Version

Your Health Isn't a Side Quest

Spoon Theory, Basically

Making Myself Less Necessary

The Humbling Part

Environment Matters More Than Salary

The Short Version

Part 1 : Building a Game in 30 Hours Using AI — Here's the Actual Timeline

The Commit Log

What "AI-Assisted" Actually Meant

The Method Behind the Numbers

Why the Timeline Matters

What the Numbers Don't Show

Supercharging Your AI Agents with Pydantic: A Developer's Guide 🚀

Table of Contents

Introduction 👋

What is Pydantic and Why Should AI Developers Care? 🤔

The AI Agent's Output Problem 🤖💬

How Pydantic Makes AI Agents More Reliable 🛡️

1. Automatic Type Conversion

2. Clear Error Messages

3. Schema Generation for Guiding AI Outputs

Real-World Use Cases 🌍

OpenAI Function Calling + Pydantic

Multi-Agent Systems (CrewAI)

Best Practices for Using Pydantic with AI Agents ✅

1. Start with a Clear Data Model

2. Handle Validation Errors Gracefully

3. Consider Re-Prompting When Validation Fails

A Simple Tutorial: Getting Started with Pydantic and AI 🏗️

Step 1: Define Your Pydantic Model

Step 2: Create a Function to Get Recommendations from an AI

Step 3: Use the Recommendation in Your Application

Advanced Tips and Tricks 🧠

Custom Validators for Domain-Specific Rules

Nested Models for Complex Data

Working with LangChain's Pydantic Output Parser

Conclusion 🎯

TypeScript Fundamentals: A Beginner's Guide (2025) ✅

1. Introduction

What is TypeScript?

Why Use TypeScript?

Real Benefits:

Prerequisites

2. Setting Up Your Environment

Installing TypeScript

Setting Up VS Code

Creating Your First TypeScript Project

8.2.1. Defining the Scripts in `package.json`