Our Blog

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.

If you’re still dealing with disconnected systems, outdated tech, and manual workarounds, you already know the pain. Missed deadlines, frustrated customers, and unnecessary costs stack up fast. What you might not know? There’s a better way.

1. Stop Wasting Time with Data Silos

Jumping between platforms, copying and pasting data, dealing with errors, it’s a nightmare. Your WMS, TMS, CRM, and ERP should work together, not fight against each other. When systems don’t communicate, shipments get delayed, customer inquiries take longer to resolve, and decision-making suffers.

How We Can Help

We integrate your systems so your data flows automatically. No more repetitive tasks, no more hunting for the right information. Just real-time visibility, and faster decisions, so you can stay ahead of demand and keep your customers happy.

2. Automate the Tasks That Drain Your Team

Repetitive tasks like data entry, tracking shipments, or fixing billing issues waste time and cause errors. They also keep your team from focusing on real priorities—optimizing operations and improving customer relationships.

How We Can Help

We automate processes that slow you down. From AI-powered customer service bots that handle routine inquiries to cost optimization models that continuously adjust for the best setup, we build solutions that deliver real impact.

Faster workflows, fewer mistakes, and no wasted time. Your team focuses on what matters. Customers get accurate updates without the back-and-forth.

3. Don’t Settle With Standard Software That Doesn’t Fit

Generic software can be too rigid or too broad, and may not support the specific workflows or integrations that your operations require. Adapting to rigid systems often means clunky workarounds, inefficiencies, and missed opportunities.

How We Can Help

We take the time to understand how you operate before building anything. Our free, no-commitment assessment includes three consultation calls:

1. Discovery Call – A logistics expert (15+ years of experience) will assess your goals, pain points, and workflows.
   
2. Deep Dive – Our technical team analyzes your software, identifies key issues, and sets clear expectations.
   
3. Proposal Review – You receive a tailored action plan with timelines and budget to optimize operations with confidence.

4. Outdated Systems Are Costing You More Than You Think

Legacy systems are slow, expensive to maintain, and full of security risks. They limit your ability to scale, increase operational costs, and put you at risk of compliance violations. Meanwhile, your competitors are upgrading, innovating, and pulling ahead.

How We Can Help You Differentiate

We help you migrate to modern, secure, cost-efficient technology. That means:

• Lower maintenance costs – Stop sinking money into outdated systems.
• Better security – Reduce the risk of breaches, data loss, and compliance fines.
• More flexibility to scale and innovate – Grow without being held back by technology and gain a competitive edge.

Get a Second Opinion Before You Invest

At Kaizen Softworks, we’ve been partnering with logistics companies, guiding them through digital transformations.

Not sure if your software is helping or holding you back? We’ll give you an honest, expert assessment before you spend a dime.

Let’s make your logistics operation work for you, not against you.

Seeing the benefits of GenAI in software development without actively exploring how to implement them in our processes feels like ignoring the obvious.

For this reason, starting this year, Kaizen is investing in developing this competency and understanding how we can apply GenAI in our day-to-day operations and leverage its benefits within software development.

We see two key ways GenAI impacts our discipline:

• Create systems with GenAI-powered features.
• Use GenAI to accelerate development.

In short we want to:

• Speed up AI adoption in software dev.
• Level up our capabilities.
• Share what we learn

To be clear: This exploration focuses specifically on GenAI, excluding other areas like Machine Learning, Computer Vision, Natural Language Processing, and Robotics.

The Tip of the Iceberg

This is not a post about the benefits of GenAI applied to software development, so I won't delve into that. I'll take it as obvious that the impact is expected to be massive and inevitable.

Faced with this large-scale transformation, it's natural that both the people who make up our teams and our clients feel curious, question its scope, and actively seek ways to incorporate this technology into their daily work.

This drive has two key engines: on one hand, the sheer magnitude of the technological disruption we are witnessing and, on the other, people's innate curiosity to explore its potential. We want to channel this energy in a structured way, ensuring that the adoption of generative AI is carried out with an organized and sustainable long-term approach within Kaizen.

Our commitment is to guide this revolution responsibly, protecting the privacy of data and the security of our clients and collaborators. The key is not just to integrate the technology, but to do so in a way that enhances human capabilities and generates a real and positive impact in our industry.

The Complex Nature of GenAI Adoption

One challenge in adopting this technology is that its process is completely different from cloud solutions, specific frameworks, or programming paradigm changes that we are already familiar with. 

A priori, the difference mainly lies in that:

• The applicability of this technology is constantly evolving.
• The value that GenAI offers depends both on the user's ability to interact with the tool and on the iterative process of constant testing and adjustment.
• New tools emerge daily but haven't yet consolidated in the market.
• It's still difficult to define what AI adoption means in more concrete terms.

Therefore, we understand that adopting GenAI cannot be done in a deterministic way. Instead, it's better to see it as a wicked problem (complex problem, without a clear or definitive solution), because there is no clear process for achieving adoption and we don't know what needs to happen or should have happened to affirm that we have adopted GenAI and that we are using it in an appropriate and productive way.

Structure and Adoption Methodology

To carry out this adoption process in an organized and effective way, we are leveraging a company area called Innovation Hub. In this space, projects are developed and teams are formed to work on different initiatives. The goal of this group is to help us expand our offerings, support the technical pre-sales team, take advantage of opportunities to improve the company's administrative and operational efficiency, and simultaneously acquire knowledge about new technologies.

This group seeks elasticity, where different people from various teams can work on a common project. It proactively encourages participation from different people, which promotes cross-pollination and a culture of innovation.

Additionally, to address the AI adoption project given the characteristics of this technology, inspiration was drawn from Henrik Kniberg's book "Generative AI in a Nutshell", especially the chapter referring to "Leading the Change."

We found in this approach a mechanism that tackles the complexity of adopting something as disruptive as AI, promotes experimentation, responsible use, and is quite compatible with our culture and organizational structure. A key characteristic is that it is bottom-up and top-down approach, seeking to viralize adoption through demonstrations of what can be done while making formal mechanisms available to make time and tools available to learn how to use it.

What's Next?

Generative artificial intelligence is transforming the software industry, and at Kaizen we are not passive spectators: we are actively exploring how to apply it in concrete, useful, and responsible ways.

As a client, this means that:

• We won't make false promises or create expectations we can't meet.
• We will test, validate, and transparently share our successes and failures.
• You'll be able to benefit from greater efficiency and new capabilities in projects, always with a pragmatic approach.

We will create spaces for dialogue to discover together how GenAI can bring real value to your business. The future is inevitable, but we can choose how to build it. And at Kaizen, we want to build it together with you.