Hi everyone. Been using Claw for about a month now after my Tabnine subscription lapsed. I'm mostly impressed, but I've noticed a consistent quirk: it gets weirdly creative with package imports, suggesting non-existent or totally wrong libraries.
It's not just a "maybe" thing. It'll confidently write code using methods from a package that doesn't exist, and the import statement looks plausible at a glance.
**Prompt:** "Write a helper function to parse a date string in ISO format and return a LocalDate object."
**Claw's Output:**
```java
import com.google.common.time.DateParser; // This is the made-up one
public LocalDate parseIsoDate(String dateStr) {
DateParser parser = DateParser.forFormat("ISO_8601");
return parser.parseToLocalDate(dateStr);
}
```
**Correct Answer:** There's no `com.google.common.time.DateParser`. Should just use `java.time.LocalDate` directly.
```java
import java.time.LocalDate;
public LocalDate parseIsoDate(String dateStr) {
return LocalDate.parse(dateStr); // Standard library handles ISO
}
```
It happens a lot—suggesting `org.apache.commons.text` for things in `java.lang.String`, or conjuring up very specific utility classes that sound right but don't exist. It adds friction because I have to fact-check every import block now.
Anyone else seeing this? Is it a known training data issue with less common languages? It's like it's pattern-matching import statements without verifying the source.
~ Jenny
Learning every day
I'm a senior dev at a mid-sized fintech, and our team's been running both Tabnine (on the paid team plan) and we've tested Claw on a few pilot projects over the last quarter. My daily stack is Java and TypeScript, building microservices and internal tooling.
Here's my side-by-side from actually using both:
1. **Price and Packaging:** Tabnine is about $12/user/month billed annually on their Pro plan. Claw is cheaper, roughly $8/user/month, but they're a newer player and I'd watch for price jumps as they scale. The hidden cost with Claw is less about money and more about developer time for corrections.
2. **Code Accuracy vs. "Creativity":** Tabnine is conservative and sticks to the standard library or your project's existing imports like glue. It's predictable. Claw is indeed more "creative," trying to suggest optimized or cleaner-looking helper classes, but it generates these plausible-but-fictional package names about 10-15% of the time in my experience. It's a real productivity hit.
3. **Speed and Integration:** Both plug into VS Code and JetBrains IDEs fine. Tabnine feels a bit faster on initial keystrokes, maybe because its model is smaller and more focused. Claw's suggestions can take an extra half-second sometimes, which adds up.
4. **Where They Excel:** Tabnine wins for straightforward, boilerplate code and staying out of your way. It's a workhorse. Claw is genuinely better at proposing novel, elegant solutions for complex logic - when it's correct. Its suggestions can reframe a problem nicely, but you have to vet its imports every single time.
Given your issue with the phantom imports, I'd actually recommend sticking with Tabnine if you're in a production environment where reliability trumps occasional cleverness. But if you're prototyping or in a greenfield research project where exploring novel approaches is the goal, Claw's "creativity" might be worth the trade-off.
To make a clean call, tell us: what's your team's tolerance for incorrect suggestions, and are you mostly maintaining existing code or writing new systems?
Data > opinions