Forem: Natan Vidra

Introducing Anote’s AI Coding Assistant

Natan Vidra — Mon, 06 Apr 2026 12:43:48 +0000

At Anote AI, we build tools that help developers work faster and more confidently. Today we’re releasing Anote — an AI coding assistant that goes beyond autocomplete to give you a collaborator that can read, understand, and modify your entire codebase.

The problem with most AI coding tools
Most AI coding tools are great at generating isolated snippets. Ask them to write a function from scratch and they’ll do it well. But real software development isn’t about writing code from scratch — it’s about understanding existing systems, finding bugs, making safe changes, and reasoning about how pieces fit together. When we asked developers what slowed them down, the answers were consistent:

“I spend more time understanding code than writing it”
“I’m afraid to touch parts of the codebase I didn’t write”
“Code review catches things, but not early enough”
“Writing tests feels like a chore I keep postponing”
An autocomplete tool doesn’t solve any of these. We built Anote to.

What Anote does differently
Anote connects Claude to your actual codebase through a set of tools — file reading, writing, editing, bash execution, file search, and code search. When you ask a question, Claude doesn’t guess; it reads the relevant files first, then answers.

Become a Medium member
This makes a significant difference in practice. Ask “How does authentication work in this app?” and Anote will:

Search the codebase for auth-related files
Read the middleware, models, and route handlers
Give you a concrete answer that references actual file paths and function names
Ask “Fix the 401 error on the login endpoint” and Anote will:

Find the login route
Read the auth middleware
Identify the bug
Edit the file with the fix
Explain what it changed and why
This is the difference between a coding assistant and a coding collaborator.

Three ways to use Anote
We built Anote for different workflows, so it comes in three forms.

The CLI — for developers who live in the terminal
npm install -g @anote-ai/anote
anote chat
The CLI gives you a full conversational interface in your terminal, plus standalone commands for common tasks:

anote fix src/api.ts --error "TypeError: Cannot read properties of undefined"
anote review --diff # Review staged changes before committing
anote commit # Generate a conventional commit message
anote pr --gh # Generate and create a pull request
The VS Code extension — for IDE users
Press Ctrl+Shift+P to install the VS Code Extension. Set your API key, and use it like you would use Codex. Conversations persist across VS Code reloads — your chat history is there when you come back.

The web app — for teams
Run a single Anote server and give your whole team access through a browser. No API keys per developer, no installs required. The web interface includes a file tree, git status panel, session management, and the same full chat capabilities as the other interfaces.

Try it today
Get started in under five minutes:

npm install -g @anote-ai/anote
export ANTHROPIC_API_KEY=sk-ant-...
cd your-project
anote chat

How to Supercharge Your Code Reviews with Anote’s AI Assistant

Natan Vidra — Mon, 06 Apr 2026 12:43:02 +0000

Code review is one of the highest-value activities in software development — it catches bugs, spreads knowledge, and keeps quality high. It’s also one of the most time-consuming, and easy to do poorly when you’re in a hurry.

At Anote AI, we’ve been thinking about where AI can genuinely improve the review process, not just rubber-stamp PRs. Here’s how we use Anote for code review, and how you can too.

The cost of shallow reviews
Most developers have been on both sides of a poor code review. As an author, you get comments like “looks good to me” on a PR that later introduced a production bug. As a reviewer, you’ve approved code while mentally exhausted, missing something obvious in retrospect.

The problem isn’t that developers don’t care — it’s that thorough code review is cognitively expensive. Tracing through unfamiliar code, holding context for multiple files, checking security implications, considering edge cases — it all requires significant mental energy. When you’re doing three reviews in an afternoon, quality degrades. AI doesn’t get tired.

Review your staged changes before you commit
The best time to catch a bug is before it leaves your machine. Anote’s anote diff --staged reviews what you're about to commit:

git add src/auth/login.ts
anote diff --staged
You’ll get a focused review of those changes — logic errors, missing error handling, security considerations, anything that looks off. It takes five seconds and has saved us from embarrassing commits more than once.

Make it a habit: run anote diff --staged before every git commit. Or better yet, use anote commit, which generates your commit message and reviews the changes in one step.

Review an entire branch before opening a PR
Before you open a pull request, get a full AI review of every commit in your branch:

anote diff -b main
This shows you everything you’ve changed relative to main. Anote reads each modified file, understands the context, and gives you feedback on:

Potential bugs and edge cases
Security vulnerabilities (missing validation, injection risks, insecure defaults)
Performance issues
Code that’s hard to follow or likely to confuse reviewers
Missing error handling
Tests that should exist but don’t
It’s like having a senior engineer pre-review your PR before other humans spend time on it.

Add context for better reviews
Code review quality improves significantly when the reviewer understands why a change was made, not just what changed. You can give Anote that context:

anote diff -b main -c "This adds rate limiting to the login endpoint. The main concern is whether the Redis TTL logic is correct."
Now the review focuses on what matters. You can also ask targeted questions:

anote diff --staged -c "I'm particularly worried about race conditions in the session management code"
Or use the full interactive chat for a deeper conversation:

anote chat

Review the changes I've made in the auth/ directory. Focus on security — are there any ways this could be exploited?
Use the VS Code extension during review
When you’re the reviewer and not the author, the VS Code extension makes it easy to ask questions as you go through unfamiliar code:

Select a confusing block of code
Right-click → Explain Selection
Understand what it does before deciding if it’s correct
Or select something that looks wrong and ask: “Is there a potential null pointer dereference here? What happens if user is undefined when this runs?"

Become a Medium member
You can also add files to the chat context and ask holistic questions:“I’m reviewing a PR that modifies auth.ts and session.ts together. Does the interaction between these two files look correct to you?”

Review for specific concerns
Sometimes you know what you’re worried about. Anote’s review command lets you focus:

Security-focused review

anote review src/api/ --security

Performance-focused review

anote review src/db/ --performance

Review a specific file in depth

anote review src/payments/stripe.ts --security --performance
Security review checks for: injection vulnerabilities, insecure deserialization, missing input validation, improper error handling that leaks information, hardcoded secrets, and more.

Performance review looks for: N+1 queries, unnecessary re-renders, blocking operations in async code, unindexed queries, memory leaks, and similar issues.

Integrate into your team’s workflow
Here’s a simple workflow that adds meaningful AI review with minimal friction:

For authors (before opening a PR):

1. Review your full branch

anote diff -b main

2. Fix anything obvious

3. Generate a commit message

anote commit

4. Generate the PR description

anote pr --copy # copies to clipboard
For reviewers (during PR review):

Get the branch

git fetch && git checkout feature-branch

Ask for a summary of what changed and why

anote ask "Summarize the changes in this branch and what they're trying to accomplish"

Deep-dive on specific areas

anote review src/affected-area/ --security
For post-merge:

Check if tests cover the new code

anote chat "Does the test suite adequately cover the new auth changes in this branch?"
What AI code review is good at (and not)
AI review is excellent at:

Finding common bug patterns — null dereferences, off-by-one errors, missing await, improper error handling
Security checks — input validation, injection risks, insecure defaults, secrets exposure
Explaining unfamiliar code — making it faster to review code outside your area
Consistency — catching deviations from patterns used elsewhere in the codebase
Coverage gaps — noticing when important edge cases aren’t tested
It’s less suited for:

Product decisions — whether a feature should work this way at all
Architectural trade-offs — these require knowing your constraints, history, and roadmap
Use AI review to handle the mechanical, exhausting parts of code review so your human reviewers can focus on the judgment calls that actually require human judgment.

Getting started
If you haven’t installed Anote yet:

npm install -g @anote-ai/anote
export ANTHROPIC_API_KEY=sk-ant-...
Then, the next time you finish a feature:

anote diff -b main
See what it finds. We think you’ll find it useful.

Anote AI Academy Fellowship

Natan Vidra — Mon, 16 Mar 2026 11:50:36 +0000

Hi All,

I am incredibly proud of the inaugural Anote AI Academy Fellowship cohort.

This past winter, our team launched a lecture series on practical, real-world artificial intelligence, featuring eight talks from leaders working at the frontier of AI. I’m deeply grateful to our amazing speakers (including Hadas Frank, Amrutha Gujjar, Jiquan Ngiam, Shafik Quoraishee, and Spurthi Setty) for taking the time to share thoughtful insights and real-world perspectives with our fellows.

Following the lecture series, each AI fellow developed a capstone project, applying what they learned to build something meaningful and personally exciting. It was inspiring to see the creativity and ambition across the cohort as everyone translated ideas into working AI systems. Some of my favorite projects came from Amelie Norris, Yidian Chen, Aadi Bery, Caleb Dickson, and Lucy Manalang, though every fellow brought something unique and impressive to the program.

AI is advancing at an incredible pace, and when it comes to education, it’s remarkable how quickly people can now learn, build, and experiment with powerful tools. Watching these projects come to life (alongside the lectures and discussions) was genuinely inspiring. Experiences like this make me rethink what education can and should look like in the age of artificial intelligence.

As part of our commitment to open learning and community building, we’ve open-sourced all of the lectures, projects, and presentation videos from the program.

You can explore them here:
https://community.anote.ai/community/academy

Why AI Systems Need Human Oversight

Natan Vidra — Sun, 15 Mar 2026 14:03:34 +0000

Despite rapid progress in machine learning, AI systems still produce errors.

These errors can take many forms:

incorrect facts,
misclassifications,
incomplete answers,
misinterpreted instructions.

Human oversight helps mitigate these risks.

In many workflows, people review outputs, provide corrections, or validate results before actions are taken.

Over time, feedback from these reviews can be incorporated into training datasets or evaluation pipelines, improving the system’s performance.

Human oversight is particularly important in environments where mistakes carry significant consequences.

Rather than replacing human expertise, well-designed AI systems amplify it by automating repetitive tasks while leaving complex judgment to people.

What Is Agentic AI?

Natan Vidra — Sun, 15 Mar 2026 14:01:13 +0000

Agentic AI refers to AI systems that can take actions in pursuit of a goal rather than simply producing single responses.

An AI agent may:

plan tasks,
call external tools,
retrieve information,
interact with APIs,
execute multi-step workflows.

Agentic systems are often built by combining language models with orchestration frameworks and tool integrations.

Examples of agent capabilities include:

searching databases,
generating reports,
automating workflows,
coordinating multiple models.

While these systems are powerful, they introduce additional complexity. Evaluating an agent requires assessing not just outputs but also the sequence of decisions and actions taken during execution.

Understanding and measuring agent behavior is becoming an important area of applied AI research.

What Is Retrieval-Augmented Generation?

Natan Vidra — Sun, 15 Mar 2026 13:58:31 +0000

Retrieval-Augmented Generation (RAG) is an AI architecture that combines document retrieval with language model generation.

Instead of relying only on the model’s internal knowledge, a RAG system retrieves relevant documents from a database and includes them in the prompt.

This approach has several benefits:

answers can reference current information,
responses can cite supporting documents,
hallucination risk can be reduced,
knowledge bases can be updated without retraining the model.

A typical RAG pipeline includes:

document ingestion
text chunking
embedding generation
vector search retrieval
prompt construction
language model generation

RAG is widely used for building knowledge assistants, document question-answering systems, and enterprise search tools.

However, retrieval quality and evaluation remain critical components of a reliable RAG system.

What Is Synthetic Data?

Natan Vidra — Sun, 15 Mar 2026 13:55:40 +0000

Synthetic data is artificially generated data designed to resemble real datasets.

In machine learning, synthetic data can be useful when:

real data is scarce,
privacy restrictions limit sharing,
edge cases are rare,

additional training examples are needed.

Synthetic data can be generated using:

generative models,
simulation systems,
rule-based generators,

hybrid approaches combining real and artificial examples.

When used carefully, synthetic datasets can help expand training coverage and improve model robustness.

However, synthetic data must still be evaluated carefully. Poorly generated examples can introduce bias or reinforce incorrect patterns.

The goal is not simply to generate more data, but to generate useful training signals that improve model behavior.

AI Benchmarks vs Real-World Performance

Natan Vidra — Sun, 15 Mar 2026 13:52:02 +0000

Benchmarks play an important role in machine learning research. They provide standardized ways to compare models.

However, benchmarks often represent simplified tasks.

Real-world environments are more complex. They involve:

messy inputs,
ambiguous instructions,
incomplete information,
evolving datasets,
operational constraints.

A model that performs well on a public benchmark may still struggle in a production workflow.

For this reason, organizations should create custom evaluation datasets that reflect their own use cases.

Testing models on representative tasks provides a much clearer picture of expected performance.

Benchmarks remain useful for understanding general model capabilities. But operational decisions should be based on evaluation against real data.

What Is Explainable AI and Why Do Users Care?

Natan Vidra — Sun, 15 Mar 2026 13:49:26 +0000

Explainable AI refers to techniques that help people understand why an AI system produced a particular result.

In many applications, accuracy alone is not enough. Users want to know:

which information influenced the result,
how confident the system is,
whether the reasoning process makes sense.

Explainability can take several forms:

highlighting supporting evidence,
showing intermediate reasoning steps,
providing confidence scores,
linking outputs to source documents.

Explainable systems help build trust because users can inspect how a decision was reached.

This is especially important in high-stakes environments such as finance, healthcare, legal analysis, and defense.

Human-centered AI emphasizes transparency and interpretability so that users remain informed participants in the decision process rather than passive recipients of model outputs.

Why AI Evaluation Should Be Continuous

Natan Vidra — Sun, 15 Mar 2026 13:45:04 +0000

AI systems do not exist in a static environment.

Documents change. User queries evolve. Workflows shift. New models appear.

Because of this, evaluation should not be treated as a one-time step before deployment.

Instead, it should be continuous.

Continuous evaluation helps organizations:

detect performance regressions,
compare new models,
measure improvements,
track failure modes,
validate system updates.

For example, a retrieval-based AI system may initially perform well but gradually degrade as new documents are added or indexing strategies change.

Without ongoing evaluation, these issues can go unnoticed.

Continuous testing transforms AI development from an ad hoc process into an engineering discipline.

The organizations that maintain strong evaluation pipelines will be best positioned to improve their systems over time.

The Difference Between AI Demonstrations and AI Systems

Natan Vidra — Sun, 15 Mar 2026 13:37:20 +0000

Many AI tools look impressive in demonstrations.

A prompt produces a well-written response. A model answers a few questions correctly. The system appears capable.

But demonstrations do not necessarily translate into reliable systems.

The difference comes down to repeatability.

A real AI system must operate under conditions where:

inputs vary widely,
edge cases appear frequently,
outputs must meet defined standards,
errors must be detectable,
performance must remain stable over time.

Achieving this requires infrastructure beyond the model itself:

evaluation datasets,
testing pipelines,
monitoring,
human feedback loops,
deployment controls.

Without these components, organizations risk mistaking a promising demo for a production-ready capability.

The gap between demonstrations and systems is where most applied AI challenges actually occur.

Why Domain-Specific AI Often Outperforms General Models

Natan Vidra — Sun, 15 Mar 2026 13:36:16 +0000

Large general-purpose models are powerful, but they are not always optimal for specialized environments.

A model trained on internet-scale data may perform well on everyday language tasks but struggle with domain-specific terminology, formatting, or reasoning patterns.

Examples include:

financial filings and earnings reports
legal contracts
medical documentation
engineering manuals
intelligence reports

These datasets contain vocabulary, structure, and implicit knowledge that general models may not fully capture.

Domain-specific AI systems address this gap through techniques such as:

fine-tuning on specialized datasets,
retrieval over domain documents,
structured labeling pipelines,
targeted evaluation.

The result is often a system that is smaller but significantly more accurate within its operational scope.

Organizations that rely on precision frequently benefit from models that are trained or adapted specifically for their domain.

This is one of the core principles behind human-centered AI: combining general model capabilities with expert knowledge encoded in data and evaluation frameworks.