Our Blog

We've all heard the promise: AI will revolutionize software development, making us faster and more efficient than ever. And yeah, AI can supercharge velocity. But in a recent project, we learned a lesson: unchecked speed often comes with some serious, hidden costs. This wasn't because the use of AI itself was flawed; it was a side effect of a project where speed was the only directive.

Our journey started like a lot of ambitious projects do: with a huge goal and a killer deadline. To hit that aggressive timeline, we pitched our client on something big: throwing AI-assisted development tools into our workflow.

The client was on board, but with one crucial condition: go fast. So, we dove into an intense two-week sprint. We slashed processes, cut back on team meetings, and pushed hard to see just how much we could get done, and how quickly.

We knew from the start that accelerating delivery by cutting some processes would introduce risk. But we also understood that this was the only viable path to meet the expectations and timeline. So we leaned into the challenge, intentionally adjusting our approach, and staying mindful of the trade-offs.

We jumped into a two-week sprint, reduced meeting time, trimmed ceremonies, and focused purely on output. The result? We moved fast, really fast. But not blindly. As we progressed, we actively tracked risks, noted what we were skipping, and prepared ourselves to course-correct after delivery.

Yes, speed delivered results, but it also surfaced important lessons about what’s worth protecting, even under pressure. And those lessons are shaping how we approach future fast-paced projects, especially when AI is in the mix.

1. Inconsistent Standards

Our codebase exploded, but it was a bit of a hot mess. Without solid process guardrails, our AI-fueled momentum became chaotic. We started asking ourselves some hard questions:

• What does "good enough" even look like for AI-generated code?
• What's our absolute minimum quality bar?
• When is this insane speed actually helping, and when is it quietly breaking everything?

We quickly realized that how you use AI is just as important as whether you use it at all.

• AI as an Assistant: Here, the developer stays in control. AI offers support, tossing out solutions or suggestions when you hit a wall. It's a more manual process, and slower, but it consistently delivers higher-quality results.
• AI as the Driver: The developer gives a prompt, and AI goes wild generating code. It's lightning-fast. But the code quality? Often compromised.

The real challenge became finding that sweet spot. Too much control, and you're not really getting the most out of AI. Too little, and you're stuck with spaghetti code that's a nightmare to maintain.

2. Unrealistic Expectations

At first, expectations were through the roof. Could we really double or triple our output overnight? The reality turned out to be a lot more nuanced.

AI shines when you're starting from scratch, making independent decisions on brand new projects, even early prototypes. But as soon as we hit real-world complexity (legacy systems, tricky architectural decisions) AI started to struggle. It needed a lot more hands-on guidance and oversight.

Suddenly, we weren't just coding. We were coaching. When we ran into complex problems, our role shifted from writing code to guiding the AI and making critical architectural calls. AI needed guardrails, decisions, and context.

That dream of 20x speed, born from unrestrained experimentation, gave way to a more practical understanding. While fast, the "anything goes" approach wasn't sustainable; it quickly led to a messy, unmanageable codebase. 

Our focus shifted from how each individual used AI to the quality of the final product. We started evaluating solutions not just by how fast they were delivered, but also by how well they stuck to our defined quality standards. Does the code work? Is it well-architected? Does it meet our minimum quality thresholds?

3. AI Magnifies What’s Already There, for Better or Worse

AI didn’t just speed things up. It amplified everything.

Think about a developer's core strengths: speed, code quality, problem-solving. Every developer naturally prioritizes some over others. With AI, these personal weightings become amplified. 

A developer who leans towards speed will become exponentially fast with AI, while someone who prioritizes quality might seem comparatively "slower" (though still faster than pre-AI). The gap between these approaches widened, really highlighting the differences within the team.

This brought up a crucial team-level discussion:

• What do we collectively prioritize?
• What standards should we uphold as a team?
• Are we truly rewarding speed… or are we rewarding actual outcomes?

We're actively working to nail that balance. The tricky part? The team isn't making all the decisions; there's a client calling the shots.

 4. The Client Sees the Speed, Not the Tradeoffs

Once you show a client you can move three times faster, how do you then turn around and say, "Actually, we could go super fast, but we're going to slow down a bit to prioritize architectural decisions"? The client will almost always push for continued speed, without fully grasping the long-term implications or the technical debt it can create. These trade-offs, which are always a part of software development, are now even more obvious and a lot harder to navigate.

This creates internal friction. A client might see one developer moving at warp speed, because that developer prioritizes speed, and then demand that everyone else match that pace. They don't see the unseen work or the critical long-term considerations other team members are prioritizing. This can lead to a perception of uneven performance within the team. AI simply highlights all of these dynamics.

The use of AI isn't up for debate anymore. It's a tempting tool for development managers, offering the illusion of doing three times more with the same resources and budget. It feels like a massive jump in computational power just by adopting AI. This has, in turn, inflated expectations, especially in the short term.

It's no longer about being 10x faster than without AI; it's now, "Hey, why are we a little slower than last week?"

The benchmark just keeps rising. Every new speed metric shared with the client becomes the new expectation. It's a continuous upward adjustment.

Closing the Loop: From Chaos to Control

It's important to remember that our experience was rooted in a high-pressure, and relentlessly fast-paced project.

We made deliberate choices to adapt to what the project needed most: speed. We knew that came with trade-offs: technical debt, uneven team pacing, and the constant pressure of rising expectations.

But instead of ignoring those challenges, we tackled them head-on. We automated where it made sense, adjusted roles, and made tough calls to preserve quality without bringing momentum to a halt.

What once felt like an impossible timeline is now within reach. The codebase is solid, the delivery date is realistic, and we’ve found a way of working that’s stable, maintainable, and far more sustainable than it was just a few months ago.

2025 is flying by, but it’s not over yet and that’s good news. There’s still time to refresh your perspective with new insights, and connections to sharpen your vision for 2026. The U.S. startup scene features high-impact conferences and summits, each providing opportunities for tactical advice, investor exposure, or peer-to-peer learning.

Below is a curated list of the most relevant startup and tech events in the U.S. from September to December 2025. 

1. Startup Boston Week

📍 Boston, MA | 🗓 September 8 - 12, 2025 | 💵 Free | 🔗 Register Now!

Startup Boston Week is a 5-day event with 100+ sessions and 300+ speakers, focused on the real work of building a startup. From product and engineering to sales and ops, there’s content for every role and stage. Whether you’re just starting or scaling, you’ll find practical advice, real stories, and people solving the same challenges you are.

• Perfect for: Founders, startup teams, early-stage investors
• Agenda Highlights: Go-to-market, hiring, product development, local VC panels

2. The Vault 25’ Conference

📍 Orlando, FL | 🗓 September 8 - 11, 2025 | 💵 $447 – $17,997 | 🔗 Buy tickets

Focused on revenue-stage startups and scale-ups, The Vault offers access to 12,000+ attendees, including 2,000+ of CEOs leading $25M+ businesses; this three-day event delivers tactical direction to scale, hire smarter, or prepare for a successful exit.

• Perfect for: Growth-focused founders, CEOs, and executives.
• Agenda Highlights: Scaling strategies, leadership, funding

3. San Francisco Tech Week 2025

📍 San Francisco, CA | 🗓 October 6 - 12, 2025 | 💵 Free & Paid | 🔗 Register now!

SF Tech Week brings together founders, builders, and top VC from all over. It’s a full week of talks, meetups, and hands-on sessions across the city. Whether you’re looking to raise money, find talent, or just learn what’s next, this is where the tech crowd shows up.

• Perfect for: Startup teams, founders, builders, anyone curious about tech
• Agenda Highlights: Fundraising, crypto, hiring, building and scaling startups

4. DC Startup & Tech Week

📍 Washington, DC | 🗓 October 20–24, 2025 | 💵 $50 – $150 | 🔗 Save the date

One of the most dynamic startup hubs on the East Coast, DC Startup & Tech Week offers 150+ events and 300+ speakers covering everything from early-stage strategy to biotech, AI, and Web3. Expect hands-on workshops, founder talks, pitch competitions, and panels with real takeaways.

If you're curious about what to expect or want a behind-the-scenes look, here’s what we learned when we attended the 2024 edition.

• Perfect for: Early-stage startups, community builders, tech entrepreneurs
• Agenda Highlights: Fundraising, product, community, govtech, DEI

5. TechCrunch Disrupt 2025

📍 San Francisco, CA | 🗓 October 27–29, 2025 | 💵 $135 – $1,105 | 🔗 Buy your Ticket

With 10,000+ attendees Disrupt is where early-stage startups and big VC money collide. The agenda covers how to raise a Series A, finding product-market fit and advice from seasoned founders. Plus, side events like pitch comps and mixers. 

• Perfect for: Founders, product leads, growth teams, investors
• Agenda Highlights: Fundraising, hiring, product-led growth, AI strategy

As part of our Innovation Hub, a group of engineers committed to exploring emerging tech hands-on, I recently ran a small but meaningful experiment. The idea? Creating a proof of concept (PoC) that merges computer vision with AI, all within a React Native app.

Why does this matter? Well, in the world of IoT, there's often a frustrating gap: how do you get digital instructions to smoothly translate into real-world, physical actions? This experiment directly tackles that challenge.

Here's how it went.

Our Computer Vision + AI Experiment in React Native

Imagine you need to draw your name on a piece of paper. Instead of just looking at an example, your phone's camera acts as your guide, giving you live instructions straight from GPT-4o (a multimodal large language model that processes images + text).

Every three seconds, the app captures a frame from the camera, turns it into a Base64 image, and sends it off to the ChatGPT Vision API. Based on what it "sees", it then streams back real-time, step-by-step guidance right onto your screen, like:

• “Grab the marker”
  
• “Take off the cap”
  
• “Draw the line”

The AI-powered visual assistant lets an app (on the user's phone) guide someone step-by-step through a physical task (like drawing or interacting with a device) in real-time, using the camera. It transforms passive instructions into an active, interactive guide.

This kind of interaction is incredibly relevant in IoT contexts, where hardware needs to bridge the gap between digital instructions and real-world actions. It’s about making complex tasks intuitive and reducing errors in the field.

The React Native Setup: Our Computer Vision PoC

We gave ourselves a tight two-week window for this experiment, with some clear ground rules:

• Tech Stack: We relied on React Native, paired with react-native-camera-vision for the camera capabilities.
• Data Flow: Capture → Base64 → ChatGPT Vision API → Streamed response → On-screen text
• Scenarios Tested: We walked through a few basic situations to see how the AI would react:
  
  • No marker → “Grab the marker”
    
  • Marker with cap → “Take off the cap”
    
  • Marker uncapped, paper visible → “Draw the line”

Insights from Our AI & Computer Vision Experiment

Like any experiment, we ran into unexpected outcomes:

• Streaming wasn't a must-have: We initially thought real-time streaming would be crucial for responsiveness, but standard API requests proved to be plenty fast enough for a smooth user experience.
  
• One frame every 3 seconds was the sweet spot: This interval hit the perfect balance between feeling responsive to the user and managing our API token usage efficiently.
  
• Token costs were surprisingly manageable: Each request/response cycle consumed around 490 tokens, with most of that coming from the image input itself.
  
• We expanded on the fly: We pushed the boundaries a bit, adding steps like "look for a piece of paper" and even challenged the assistant to guide us through writing the full word rather than just a simple line.

In our daily work with IoT companies, we build software that lives and breathes in physical spaces (think of warehouses, supermarkets, sensor installations). That’s where this kind of vision+AI combo can shine.

This particular PoC wasn't just a fun side project; it helped us:

• Explore real-time visual assistance directly within mobile applications.
• Experiment with "low-friction" computer vision, using readily available tools like React Native and ChatGPT to get quick insights.
• Build crucial internal know-how that we can directly apply to solve real challenges for our clients.

What’s Next for AI-Powered IoT Solutions?

The next iteration is already brewing. We’re exploring ways to replicate this behavior locally, no external API calls, lower latency, better privacy. Tools like TensorFlow Lite or MediaPipe are on our radar.

This experiment was just the start. But it's part of a broader strategy: build internal fluency in emerging tools that can create real value. 

AI-powered development tools are no longer curiosities, they’ve become valuable tools in high-stakes software projects. But while the promise of velocity is real, without structure it can also magnify risks. 

In this post, we share a real-world story of how we used AI to meet an impossible software migration deadline. It’s a case study in trade-offs: what happens when you prioritize velocity above all else, and how we later found a more sustainable balance.

Starting Point: Legacy Code, an Impossible Timeline

Picture this: a core business web application, used daily by thousands, built on outdated tech and riddled with security issues. That was our starting point.

This platform was massive: highly modular, deeply entangled, and heavily customized for each client. Migrating it to modern technologies wasn't just a nice-to-have; it was a necessity as technical debt was increasing. Engineers initially estimated 18 months for the job, but leadership unilaterally slashed the deadline to 12 months. No justification. Just pressure.

Our team of four Kaizen developers, working alongside two third-party vendor engineers and our client's internal product team, was asked to make it happen. From the start, it was clear: the numbers didn't add up.

Growing Pressure and Shrinking Options

Progress was steady, but the gap between effort and scope was too big. As weeks passed, pressure grew. Everyone on the ground could see what was coming: we weren't going to make it on time.

The challenge wasn’t just technical. Our client operates in a deeply hierarchical and bureaucratic environment. Technical realities that were obvious to us on the ground often had zero visibility to the top-level decision-makers. 

So we started exploring every possible option: adding more developers to the team, or even shrinking the scope of the migration to launch an MVP faster. 

It was clear something had to give, but getting that message through the layers of management was incredibly difficult. None were greenlit. We needed a new approach, and fast.

The AI Spark: From Skepticism to Experimentation

Around this time, new AI-powered code generation tools were gaining traction, like Windsurf, a fork of Visual Studio Code powered by an autonomous agent named Cascade. These tools could generate code using natural language prompts, and they could do it fast.

We saw an opportunity. Within Kaizen, our Innovation Hub—a dedicated group of engineers from various projects—had already begun experimenting with different code generation tools, including Windsurf. Their mission was to explore cutting-edge tech, drive innovation, and ultimately enhance the value we deliver to our clients.

So, we pitched it to the client. Their first reaction was a hard "no." Security and privacy were their main concerns. They feared code exposure or leaks, and worried their data might be used to train public AI models.

To address this, our team proposed a controlled experiment using an internal, locally hosted AI model, like a "KaizenGPT." This guaranteed no client data would ever leave our servers. It was slower than commercial models, but it built crucial trust.

After seeing positive early results (all on test projects, without using actual client code), our client began to soften. That's when we introduced a more robust setup: Windsurf, paired with paid access to enterprise-grade models. These licensed models offered stronger privacy controls, encryption, and data usage guarantees (backed by certifications) that free versions simply don't provide. That added layer of security and compliance made all the difference. We finally got the green light to start using AI responsibly.

The AI Boost Sprint: Speed at All Costs?

Once the use of AI in their codebase was approved, what followed was a direct, almost chaotic directive: "For two weeks, no meetings, no usual processes, just code! Use AI and push as hard as you can."

At Kaizen, we knew cutting corners on processes wasn’t a sustainable approach. But we also saw the cold, hard truth: at that moment, velocity was the biggest threat to the entire project. We made a deliberate choice to dive into this experiment, fully aware of the risks, because we believed the potential gains were worth exploring.

This sprint became our real-world test: How much acceleration could AI truly bring to our workflow? Could those speed gains actually outweigh serious concerns about code quality, long-term maintainability, and even our team's well-being?

And we did it. Two weeks of intense, AI-driven code generation. We saw incredible speed, yes, but it came at the cost of many things: our team's processes, and code quality, which became poorly defined as everyone adopted AI in their own way, searching for the "optimal" method.

We made tremendous progress, but we also introduced inconsistencies in standards, code style, quality, and even team communication. Many aspects suffered in the race to move forward with AI.

But this wasn't an AI problem; it was a project context problem. The directive was simple: speed, speed, and let's see how far AI can take us to determine if it's worth continuing.

The Search for Balance: Not Everything is Speed

The plan was never to keep running at unsustainable speed. Once the sprint ended, we reviewed the outcomes and pivoted back to our normal processes, with one key difference: AI was now part of them.

So the challenge shifted: how should we actually use AI in a sustainable way?

We started defining standards and best practices. Over time, we discovered how to optimize our approach, bring order to the chaos, and find the right balance between AI assistance and manual work.

Reporting from Santa Clara, the IoT Tech Expo North America returned on June 4–5, 2025, at the Convention Center, bringing together a rich mix of IoT, AI, Big Data, Cybersecurity, Edge Computing, and Digital Transformation under one big roof. While organizers projected over 8,000 attendees, I’d estimate it was closer to 5,000–6,000.

A Showcase of IoT Ecosystem

Walking the expansive expo floor, you could clearly see the four key pillars of IoT represented across hundreds of booths:

• Hardware: sensors, gateways, and edge devices
  
• Firmware: embedded systems and device software
  
• Communications: connectivity standards like 5G, LoRaWAN, and others
  
• Software: platforms that process, analyze, and secure the data

Industrial IoT & Industry 4.0 Took Center Stage

We focused heavily on the Industrial IoT & Industry 4.0 track. Sustainability, automation, and smart factories dominated the discussion.

 Highlight: PepsiCo’s Real-World IIoT Case

In a standout session titled "AI, IIoT and Delivering Business Impact," Prashanth Srinivasan, Head of Architecture at PepsiCo, gave a deep-dive into how they applied IoT and AI to increase chip packaging throughput by 7% at their Vallejo, Mexico plant.

It was a highly technical talk, but the business takeaway was crystal clear: when done right, AI + IoT = real operational impact.

Highlight Talk: IoT at PepsiCo

In this session led by Prashanth Srinivasan, Head of Architect at PepsiCo, called "AI, IIoT and Delivering Business Impact." He walked us through a highly technical, yet incredibly relatable, case study. He detailed how PepsiCo leveraged AI + IoT to increase chip packaging throughput by a remarkable 7% at their Vallejo, Mexico facility. It was a concrete example of how these technologies translate directly into tangible business impact.

The Power of Modular “Building Blocks”

Another standout presentation came from Tom Clements, VP of Sales, in “Powering the Connected World in IoT.” He emphasized the critical need for IoT Best Practice Building Blocks, stressing that successful IoT solutions must be:

• Modular and componentized: Think Lego bricks, not monolithic structures. Componentized systems allow for easier scaling and updating.
• Built for timely data ingestion: Getting the right data, at the right time, is non-negotiable. You can’t act on what you don’t know in time.
• Backed by strong identity and device management: Security and control start at the device level.
• Capable of detecting failures down to a single device, anywhere in the world, in real-time: Because when things break, you need to know immediately where and why.

AI + IoT = The Real Synergy

Another session that stuck with me featured Martin Whitlock, CTO of Telenor IoT, hosted by Sudha Jamthe, tech futurist and Principal at the Business School of AI. They made a compelling case for AIoT, the intersection of AI and IoT, as the future of connected systems.

Their core insight:

IoT produces the data; AI gives it meaning. Together, they’re reshaping everything from predictive maintenance to supply chain optimization.

Personal Takeaways & Observations

• Scale is real: Hundreds of booths, thousands of attendees (photographs just can’t capture it all.)
• Booths mirror the full IoT lifecycle: Saw everything from sensor design to cloud analytics.
• Industrial IoT is the leader: especially in manufacturing, logistics, and utilities.
• AI isn’t optional: Every platform now integrates AI. Without it, it’s hard to compete.
• Security and trust aren’t afterthoughts: Certifications and device identity popped up in nearly every session.
  

Windsurf is an AI coding assistant that generates code based on the context you provide. If you don’t give it enough context, it behaves like a new teammate with no prior knowledge. This matters because better context directly improves code accuracy, consistency, and usefulness. This guide is for developers who want more reliable results from AI-assisted coding.

Key Takeaways

• Windsurf does not retain full context by default, so you must provide it explicitly.
• Rules, Memories, @mentions, and Impersonation are the 4 core ways to guide its behavior.
• Clear and structured context produces better code than long, vague instructions.

What is Windsurf in AI coding?

Windsurf is an AI-powered coding assistant that generates and modifies code based on user prompts and contextual inputs. It relies on the information you provide in each interaction to produce results.

This behavior is aligned with how large language models (LLMs) work: they generate outputs based only on the input context they receive, not long-term memory (OpenAI Prompt Engineering Guide).

Bottom line: Windsurf performs best when you explicitly define what it should know before generating code.

Why does Windsurf need context to generate better code?

Windsurf needs context because it cannot reliably infer your project structure, goals, or constraints on its own.

Without context:

• It may generate incorrect or irrelevant code
• It can modify unintended files
• It may ignore project-specific conventions

Research on generative AI systems shows that models perform better when given explicit instructions and relevant examples (Google Cloud Prompt Design Guide).

With proper context:

• Code aligns with your architecture
• Outputs are more predictable
• You reduce rework and corrections

Conclusion: Context acts as the “memory layer” that makes AI outputs usable in real projects.

How to use Rules in Windsurf?

Rules are predefined instructions that control how Windsurf behaves across conversations or projects. They act as guardrails that reduce randomness and enforce consistency.

Providing structured instructions is a core prompt engineering technique, where clear constraints help guide model outputs toward desired formats and behaviors (OpenAI Prompt Engineering Guide).

Types of Rules

How to use Rules effectively (step-by-step)

1. Define behavior clearly
   Example: “Use TypeScript for all code.”
2. Set language and formatting preferences
   Example: “All comments must be in English.”
3. Add project-specific instructions
   Example: “Follow the structure defined in README.md.”
4. Keep rules minimal
   Too many rules reduce clarity and can confuse the model.

Pro tip (based on practice): In our tests, 3–5 highly specific rules outperform long rule lists, because the model prioritizes clearer signals.

Bottom line: Use fewer, clearer rules to guide consistent outputs.

What are Windsurf Memories and When Should You Use Them?

Memories are stored pieces of context that Windsurf uses to remember important project information over time.

They function similarly to persistent notes about your project.

How Memories work

• Windsurf can auto-generate memories based on conversations
• You can also manually create memories
• ‍ They are project-specific (not global)
• ‍You can edit them anytime

Example of a Memory

“This app is a SaaS dashboard for managing subscriptions.”

When to use Memories

Use Memories when:

• You are working on long-term projects
• You want to avoid repeating the same explanations
• Your project has stable requirements
• You need consistent context across sessions

Avoid overusing Memories when:

• You want exploratory or creative outputs
• Your project changes frequently

Important limitation: Memories can become outdated if your project evolves, so you must review and update them regularly.

Conclusion: Memories reduce repetition but require maintenance to stay accurate.

How to Use @mentions in Windsurf to Provide Context?

@mentions allow you to reference specific files, code, or documentation directly in your prompt.

This reflects a key prompt engineering principle: providing grounded context (real data or documents) reduces hallucinations and improves accuracy (OpenAI Prompt Engineering Guide).

Examples of @mentions

• @README → Loads project overview
• @server.js → References backend logic
• @/components/Button.tsx → Targets a specific UI file

How to use @mentions (step-by-step)

1. Reference the exact file or resource
2. Give a clear instruction
   Example: “Read @README and summarize the architecture.”
3. Limit scope
   Prevents Windsurf from modifying unrelated files

Why this works:
You eliminate guesswork by forcing the model to use real project data instead of assumptions.

Bottom line: @mentions are the fastest way to inject precise, relevant context.

What is "Impersonation" in Windsurf and How Does it Work?

Impersonation is a technique where Windsurf adopts a specific role or persona to guide its outputs.

This is similar to role-based prompting, a widely used technique where assigning a role improves output relevance and tone (OpenAI Prompt Engineering Guide).

This is useful for tasks that require a particular perspective, such as design, QA, or architecture.

Example of impersonation

“Impersonate a senior UX designer focused on usability.”

Advanced use: Persona files

You can create reusable profiles (e.g., @luna.md) that define:

• Tone
• Priorities
• Constraints

Then use: “Impersonate @luna”

Use cases for Impersonation

• UX/UI design perspectives
• Code review roles
• Architecture decision-making
• Testing and QA validation

Why it works

Impersonation narrows the model’s decision space by:

• Defining priorities (e.g., usability vs performance)
• Applying consistent criteria across outputs

Real-world workflow tip: In practice, teams use impersonation to:

• Generate quick prototypes (HTML/CSS)
• Validate ideas before implementation
• Run AI-powered code reviews after development

Conclusion: Impersonation adds focus and expertise to AI outputs.

Rules vs Memories vs @mentions vs Impersonation

How to give Windsurf the best context (Checklist)

Use this checklist before prompting:

• ✅ Define clear rules
• ✅ Add key memories
• ✅ Reference files with @mentions
• ✅ Use impersonation for complex tasks
• ✅ Keep instructions short and specific

Common mistakes when using Windsurf

• ❌ Giving too many rules at once
• ❌ Not updating memories after changes
• ❌ Writing vague prompts
• ❌ Not referencing actual files
• ❌ Expecting Windsurf to “just know” your project

Fix: Always provide explicit, structured context.

Final Summary

To get better results from Windsurf, you need to control its context.
Use rules for consistency, memories for persistence, @mentions for precision, and impersonation for focus.

The clearer your context, the better your code.

If you're curious about where AI is headed in software development, it's time to pay attention to Windsurf: an IDE powered by artificial intelligence that feels less like a tool and more like a copilot.

In our previous blog post, we went over the basics of what’s Windsurf and how it works. Now, let’s walk through a simple, step-by-step guide to help you get started.

Step 1: Plan Your Project

Before you jump into coding, take a step back and plan. This is where ChatGPT (or another conversational model) can shine. Use it to brainstorm ideas, organize your thoughts, and shape your prompt.

Let’s say you want to build a chatbot. You can ask ChatGPT to help you structure a well-defined prompt tailored for Windsurf.

🔍 Pro tip: The more complex or abstract your prompt is, the higher the chance of messy or overly generic code. If long-term maintainability matters, spend time writing a thoughtful prompt.

Step 2: Choose the Right Model

On the right side of the Windsurf interface, you’ll find Cascade, your AI copilot. Cascade can tap into several powerful foundation models:

Each of these models brings its own strengths, and you can choose which one to use based on your goals or the task complexity. 

Some models, like Sonnet 3.7 (Thinking), use internal reasoning steps before generating final output. You’ll see the model “think out loud,” iterating on your prompt in real time. These “thinking” models are more resource-intensive and slightly slower, but they’re better at solving complex problems. 

However, they can sometimes overcomplicate things or drift off-track. A helpful strategy is to use them for ideation and problem-solving, then switch to a faster, more direct model for implementation.

🧠 Is one model better than the others? Sometimes. But results are non-deterministic. The best way to find what works is to experiment with models and prompt variations.

Step 3: Give Windsurf the Right Context

Windsurf starts every session with a clean slate. This means it doesn’t remember anything you’ve said in past conversations.

Just like you would explain things to a new teammate, you’ll need to provide all the relevant information upfront before asking it to write code. For example:

If you're building a chatbot, you might begin by asking Windsurf to read a README file so it understands the system’s specs and expected behavior.

Context is everything. Without it, Windsurf can’t generate helpful code. Here’s how to provide the right context:

• Upload or paste documentation (README, API references, etc.)
  • Pro tip, ask Windsurf to generate the README file and documentation in MD format, and then edit it accordingly
    
• Use features like rules and memories to keep recurring information handy

⚠️ Reminder: Windsurf doesn’t retain information between sessions unless you explicitly use memory or rule features. Be intentional and include all necessary context up front.

Want to go deeper? Check out our dedicated blog post on giving Windsurf proper context.

Step 4: Paste Your Prompt

Once you’ve set the context, paste your prompt into the same conversation thread. From here, Windsurf takes over, picking the right tools, building your code step by step, and shows you its thinking along the way. 

Before making any changes to the code, always present the plan and ask for confirmation.” That way, we can review it, and models don’t go ahead and make changes on their own. So that’s a rule we should always stick to.

You can ask for edits, improvements, or further explanations as you go.

Step 5: Run Your App on Localhost

One of Windsurf’s most powerful features is its ability to generate full-stack applications (frontend and backend) in just minutes. It can:

• Configure your environment
  
• Generate working code
  
• Run it locally using the “One Shot” flow

One Shot = one solid prompt → full app prototype

This is fantastic for prototyping and fast iteration. But it’s not a replacement for good software engineering practices.

💡 Important: One Shot outputs aren’t production-ready. Always review the code. AI can take you far, but great software still needs great developers behind it.

Step 6: Make Changes & Refine

Windsurf extends beyond the chat interface by offering intelligent autocompletion within the code editor, providing contextually relevant suggestions as you type.

Plus, there's this cool shortcut: Command + L. By selecting a portion of code and using this command, you can then enter instructions such as "comment this function," and Windsurf will propose the corresponding modification.

For every change Windsurf suggests, a little window will show up where you can check out the proposed code edits and either click "Accept" or "Decline".

Now, here's the deal: If you don't like what Windsurf makes and you just keep telling it to change stuff over and over, it can start adding a bunch of extra, messy code. It will keep adding new styles without getting rid of the old ones. It can get into this weird loop where it just keeps piling on code, and you won't even know what's being used and what's just junk.

Think about it this way: when you come back to your project tomorrow, Windsurf won't remember any of your previous chats. So, it'll use its search tool, find some old style that's not even being used, and try to change that instead. Then, nothing works, and you're wondering what's going on.

Remember, Windsurf's memory is short. It's like saying "hi" and having to introduce yourself again the next time. That's why writing clean, organized code makes it way easier for Windsurf's search tools to do their job right.

So, one of the best ways to handle this is to go back a step. You can literally tell Windsurf, "Forget that," using the "truncate conversation" feature. It's pretty sweet because you can hit "Revert this step," confirm it, and Windsurf will not only forget what it just did but also undo the code changes.

Bottom line: It's usually better to tweak your original prompt and go back than to keep asking Windsurf to fix something you didn't like in the first place. 

Wrap Up

Start small. Test different models. And most importantly, don’t skip the human touch. Even with powerful AI, great software still depends on great developers.

👉 Next up: We'll walk through the best ways to give Windsurf context so you can get even more of its potential.

If you’re a software developer, you’ve probably used an Integrated Development Environment (IDE) like Visual Studio Code to write, test, and debug code.

Now imagine that same workspace, but with an intelligent assistant that does some of the work for you. That, in essence, is Windsurf. Let’s go over the essentials of this new AI tool. 

What is Windsurf Editor?

To give you a quick idea, Windsurf is like a Visual Studio Code pumped up with AI on steroids. Technically, it's a fork of VS Code, which means it takes the solid, open-source foundation of VS Code and adds new AI-powered functionalities. 

What Makes Windsurf Different?

Windsurf’s standout feature is its autonomous AI agent, called Cascade, that can understand natural language, perform complex coding tasks, and interact with your project. Think about having a virtual programming buddy you can talk to and ask to do things. 

This agent not only understands your commands but is also capable of chaining together several complex actions to achieve your goals, like: 

• Read library documentation: You can ask it to search for specific information on the web or even pass it a repository link.
• Modify your code: It can help you refactor, add new features, or fix bugs.
• Manage your environment: It can create new folders or execute commands directly in your terminal.

💡This autonomous agent isn't here to replace you as a programmer. Instead, it aims for an intelligent collaboration. You NEED to give them the context and instructions, MUST review its suggestions, and HAVE TO accept or decline the results. 

The Tools Behind the Agent

To carry out these complex tasks, Windsurf provides its autonomous agent with a series of specialized tools:

🔍 Search & Discovery

• grep: Searches for text in files
  
• listdir: Lists project folders and files
  
• web search: Looks things up online
  
• embedding search: Finds semantically related content, even if you don’t use the exact same words
  
• MCP: Stands for Model Context Protocol. It allows the AI to safely use external tools (often built by third parties) by following a structured set of rules.
  

✏️ Editing & Modification

• make edit: Makes inline code edits
  
• add file: Creates new files
  
• and other requests 

✅ Verification & Execution

• Runs terminal commands
  
• Executes tests or scripts to confirm things are working
  

How Does Windsurf Editor Work?

Windsurf’s workflow has three key parts:

1. The Prompt: You give the instruction (prompt) to the agent through a conversational interface that can understand text, images, sound, and video.
2. The Brain: The brain of Windsurf uses the LLM of your choice, interprets your instruction and determines what needs to be done.
3. The Tools: Based on your prompt, the LLM learns to select and use the appropriate tools (read files, edit, search, etc.) to fulfill your request.
   

It's important to understand that LLMs are probabilistic, meaning that given the same instruction, they won't always generate the same response. 

In the context of programming, where we seek precise results, this highlights the importance of clear human guidance and careful review of what the agent proposes. If your instruction is ambiguous, the result could be either useful or completely wrong.

What Windsurf Can (and Can’t) Do

Windsurf runs on different large language models (LLMs), like the ones behind ChatGPT or Gemini. These are foundational models trained on massive amounts of data, giving them broad general knowledge. 

Each prompt uses "credits" that get renowned each month if you have a pro or enterprise plan. Be careful as more advanced models are more expensive and cost more credits per prompt.

However, they don’t know everything. If something wasn’t part of the training data, or if it happened after the model’s cutoff date (e.g., June 2024), the model won’t know it unless you tell it. This means it wont be able to use the latest version of some libraries so always ask the model "what’s the latest version of x" to double check. 

Also, no AI model fully understands the current state of your code or documents out of the box. That’s why Windsurf uses the tools mentioned above to explore your project and understand it, just like a developer would.

Windsurf relies heavily on context, meaning what you've asked before, what files it has seen, and any information you’ve shared in the session. But it doesn't "learn" new information permanently. For example, if you send it a link, it might use that content during the current conversation, but it won’t remember it afterward. It treats that as temporary context, not long-term memory.

Final Thoughts

Being among the first IDEs to fully integrate an autonomous AI agent, Windsurf offers a unique approach to coding. Used well, it can help you stay in flow, reduce context-switching, and explore solutions faster.

Ready to start programming with Windsurf? Check out our step-by-step guide and tips here.

The 2025 TIA Capital Ideas Conference kicked off with powerful messages, sharp insights, and clear calls to action for the logistics industry. With over 1,500 attendees gathered, Day 1 delivered impact and inspiration, especially in a time when freight fraud, cybersecurity, and tech adoption are reshaping how 3PLs and carriers operate.

Here’s what stood out, what we’re still thinking about, and what it means for the future of freight.

TIA Sets the Tone: Industry Voice, Unity, and Innovation

TIA Chairman Mark Christos opened the event with a warm welcome, celebrating the organization’s 40+ year legacy. With over 3,500 CTB (Certified Transportation Broker) professionals certified, TIA continues to invest in education and elevate industry standards.

Key Day 1 highlights:

• Avalon Risk Management awarded scholarships to 4 rising professionals
• Truckstop recognized 3 outstanding Women in Transportation
• Rob Kemp, incoming TIA Chairman, spotlighted cargo theft as a billion-dollar issue
• Chris Burroughs, TIA CEO, emphasized the association's shift toward representing all of logistics—not just brokers. TIA is clearly pro-carrier, advocating for greater unity in a historically divided space
• 80,000 freight fraud complaints were filed—prompting a September lobbying push in D.C.
• A new Technology Committee will focus on adoption, security, and collaboration

Opening Keynote: Frank Abagnale's Wake-Up Call on Cybersecurity

Frank Abagnale, the real-life inspiration behind Catch Me If You Can, opened the conference with a sobering keynote on cybercrime, identity theft, and scams. A bestselling author and FBI educator for over 40 years, Abagnale’s formula was simple but urgent:

Prevention. Verification. Education.

He left the room with alarming stats:

• 🔐 91% of stolen money is never recovered
• 👤 3.6 billion identity records compromised in 2024
• ⚖️ Less than 0.005% of cyberattacks are prosecuted
• 🔑 Passkeys are set to replace passwords entirely

Session Highlight: You’ve Selected New AI Tech—Now What?

Moderated by Dawn Salvucci-Favier (CEO, Greenscreens), the panel brought together Kevin Sendre, Julia Hoult, and Greg Finnerty to tackle the real-life challenges of implementing AI in freight.

Key takeaways:

• AI isn’t just about ROI—it’s about improving team experience and workflow
• Transparency in data sources is critical
• Security risks emerge when giving access to external AI providers
• Adoption starts with training, clear process improvement, and buy-in
• Brokers must address ego, tribal knowledge, and system overload to succeed

“AI is your teammate. It’s the cost of doing business—your competitors are already using it.”

M&A Insights from Republic Partners

Michael Nolan from Republic Partners shared valuable insight into M&A trends in logistics—especially for family-owned firms.

Highlights:

• Logistics firms are increasingly judged by their tech stack and IP
• Republic builds long-term relationships before any transaction—no upfront fees
• Sellers are expected to circle back when they’re ready to move
• Tech is no longer a differentiator—it’s a requirement
• For tech due diligence, they work with West Monroe

Open questions we’re still reflecting on:

• How do they assess a company’s tech pre-diligence?
• How much does strong tech truly impact valuation multiples?

Political Outlook: Tariffs, Trade, and Freight Policy

In a heated political panel, Scott Jennings (CNN), Seth Clevenger (Transport Topics), and other experts unpacked the future of global trade and domestic manufacturing.

Main takeaways:

• Tariffs may become a long-term reality—especially with Trump likely back in play
• Expect a decoupling from China and deals with other regions
• Freight leaders must remain nimble and adaptive
• There’s a push to bring manufacturing back to the U.S. and boost wages
• Lobbying opportunities may open as red tape is reduced

"This is a restructuring of the world trade order that works for working Americans."

Industry Reflections: The Evolving Role of Brokers and Carriers

• The divide between brokers and carriers still runs deep—but there's hope for alignment
• Freight theft is an emerging and urgent concern
• Brokers are still seen as faster-moving and more aggressive than carriers
• People remain the most valuable asset in 3PL firms—especially in the M&A context

Final Thoughts 

Day 1 of the TIA Capital Ideas Conference set the stage for big conversations in logistics—from cybercrime to AI, M&A to political strategy. Whether you’re a broker, a carrier, or somewhere in between, one thing is clear:

The future of logistics will be shaped by how well we adapt, protect, and innovate—together.