From Treadmill Dust to Family Fun: Code Review Lessons from a HarmonyOS Fitness App

When Home Fitness Apps Become Dust Collectors

The treadmill in the corner—everyone knows it. Bought with enthusiasm, used twice, then relegated to holding laundry. This is the problem Lince Wander set out to solve. Not by making a better treadmill, but by rethinking what a home exercise device could be. The result is a HarmonyOS app paired with a walking machine that turns your steps into game controls on a Huawei Vision screen.

But building this wasn't just about game design. It was about code review, system integration, and the countless small decisions that make a product feel responsive instead of laggy. Let's look at what the team learned—lessons that apply to any developer working with smart displays or complex hardware-software interactions.

The Core Challenge: From "Should Exercise" to "Want to Play"

Traditional fitness equipment suffers from a motivation gap. You know you should use it, but the repetition is mind-numbing. Lince Wander's answer is to make movement itself the interface. Users walk or run on a 1.2-meter-wide platform, and their steps drive a 4K scenic trail or a 3D adventure game. You dodge obstacles, collect items, and interact with characters using hand gestures.

This approach required a fundamental shift from thinking of the app as a fitness tracker to seeing it as an entertainment platform. The team behind it, led by product manager Zhou Jing, realized early that the real competition wasn't other fitness apps—it was boredom.

Why HarmonyOS? The Ecosystem Decision

Choosing HarmonyOS wasn't a casual move. The team spent months evaluating TV ecosystems and found most were fragmented. Different brands had wildly different capabilities—some had cameras, others didn't; chip performance varied hugely. For an app that relies on skeletal tracking and real-time rendering, that inconsistency is a nightmare.

HarmonyOS offered something different: a unified approach to multi-device interaction. The distributed architecture means the walking machine, the Vision screen, and other smart home devices can work together seamlessly. But that promise came with trade-offs. The team had to commit exclusively to HarmonyOS, forgoing other TV platforms for a while. It was a bet on the ecosystem's growth.

Code Review in Practice: What We Can Learn

Let's talk about code review. When you're building for a new platform, every line of code is a potential landmine. Here are the key areas the Lince Wander team focused on, and what you should look for in your own reviews.

1. Skeleton Tracking: The 2D vs. 3D Problem

One of the first hurdles was skeletal recognition. The early HarmonyOS SDK only offered 2D pose estimation, while the team was used to 3D from Android. This isn't just about fancy visuals—2D means fewer data points, making it harder to accurately detect user actions. In code review, you'd flag this as a risk: "We're building on a less reliable foundation." The team had to adapt their algorithms and wait for the system to improve.

2. Model Optimization for Limited Hardware

TV chips aren't as powerful as phone processors. The team initially loaded complex 3D models onto the Vision screen and found the characters wouldn't move—the models were too heavy. The fix involved compressing models, adjusting textures, and testing repeatedly. In code review, this is where you'd scrutinize asset loading, memory usage, and frame rates. You can't just throw bigger hardware at the problem; you have to make the software leaner.

3. Latency: The Invisible Dealbreaker

Latency is everything in interactive experiences. The walking machine sends motion data to the app, which then updates the screen. Initially, Bluetooth had noticeable lag. Switching to Huawei's NearLink technology cut that delay dramatically. In code review, you'd be looking at network protocols, data serialization, and UI update loops. Even 50 milliseconds can make the difference between "natural" and "floaty."

4. Handling System Upgrades

When HarmonyOS updated from 5.x to 6.x, the app broke—videos went black. This is a classic integration issue. The team had to work with Huawei's engineers, attending meetings and debugging together. In code review, you'd ask: "Do we have fallback strategies for OS changes?" and "Are we testing against beta versions?" It's a reminder that your code doesn't live in a vacuum; it's part of a larger ecosystem that evolves.

User Feedback as a Code Review Tool

At HDC 2026, the team saw firsthand how users interacted with the device. Kids lined up repeatedly to play the game, while older users asked about cushioning and stability. This feedback loop is like a real-world code review. It reveals edge cases you didn't consider. For instance, some users initially lifted their feet too high because they didn't know how to walk on the machine. The team realized they needed better onboarding—clearer instructions, maybe audio cues.

This is where code review meets UX. You can have perfect logic, but if the user can't figure out how to start, it's a bug. The team plans to add guided tutorials and more intuitive content selection.

Future Plans: Networking and Health Data

Users at HDC asked two big questions: "Can I play with friends online?" and "Does it track my health?" The first is about social features—something the team is exploring. The second involves integrating with Huawei's Health app, which requires navigating API permissions and data privacy rules. Both are substantial projects that will need careful code review to ensure reliability and security.

Long-term, the team envisions personalized recommendations based on family members' health data. If grandma steps on, the system suggests a gentle forest walk; if a kid steps on, it offers a more energetic game. That's a complex recommendation engine, and it's not built yet. But it shows where the product is heading.

Conclusion: The Real Difference

So, what makes Lince Wander different from a treadmill? It's not one feature—it's the entire approach. A treadmill is a machine you have to convince yourself to use. Lince Wander is a game you want to play. The code review process was instrumental in making that happen. Every latency fix, every model optimization, every system upgrade patch contributed to the seamless experience users feel.

For developers, the lesson is clear: code review isn't just about catching bugs. It's about understanding the platform, anticipating user needs, and being willing to iterate. The HarmonyOS ecosystem is still maturing, but products like Lince Wander show what's possible when you commit to a platform and work with its strengths.

If you're building for smart displays or any hardware-software hybrid, take a page from their playbook. Test early, test often, and never underestimate the importance of a well-reviewed codebase.