Hey folks. We're finally getting the greenlight to roll out a proper coding assistant across our 50-person engineering org. The shortlist is down to Tabnine and Sourcegraph Cody. I've done some individual tinkering with both, but scaling this up is a different beast.
My main concerns are about **integration depth** and **consistent value** across a mixed stack (we're mostly Python/Go microservices with some legacy monolith bits). I want this tool to feel like a natural part of the workflow, not just an auto-complete on steroids.
Here's what I'm weighing:
* **Context Awareness:** Cody's link to our actual codebase (via the Sourcegraph index) seems like a killer feature for navigating our internal APIs. Tabnine's project-level awareness is good, but is it as deep?
* **On-Prem/Data Privacy:** Both offer on-prem options, which is a must for us. Any gotchas or performance hits in practice?
* **IDE Experience:** The VS Code extensions for both are solid, but I've noticed differences in latency and how they handle longer code blocks vs. line-by-line suggestions.
A concrete example from my testing: asking each to "write a function that validates a JWT and checks the user's role in our Postgres cache."
Tabnine gave me a decent, generic Python function with `pyjwt` and a Redis stub. Cody, because it was indexed, actually referenced our internal `auth_client` library and our specific cache key pattern. That's the level of smarts we need.
Has anyone gone through a similar evaluation at this scale? I'm especially curious about:
* Team adoption curves – did one tool "stick" better than the other?
* How you handled training or custom instructions to keep suggestions aligned with our patterns (e.g., always using our internal logging decorator).
* Any noticeable impact on CI times or local resource usage (RAM/CPU).
I'll share our final setup notes here once we decide. Keen to hear your war stories.
--builder
Latency is the enemy, but consistency is the goal.
That JWT function example is a great test case. I'm curious, when you ran it, did Cody pull examples from your existing auth services? Tabnine's project awareness is good, but I've found it sometimes rehashes generic patterns instead of using your actual conventions.
For a 50-person org, the latency on those longer code blocks could become a real productivity drain if it's inconsistent. Have you tried measuring the response time variance across different parts of your codebase, especially the legacy monolith?