Last week I shipped a Model Context Protocol (MCP) server for my analytics SaaS. Now Claude Desktop, Cursor, and any MCP compatible client can query traffic, revenue, and funnel data directly.

This is a walkthrough of how I built it, what worked, and a couple of patterns that surprised me.

What MCP is, briefly

MCP is a protocol that lets AI clients invoke tools and read resources from external servers. Think of it as REST for LLM tool calling, with a stable schema and discovery.

Server skeleton

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const server = new Server({
  name: 'zenovay',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
    resources: {}
  }
})

Defining tools

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_traffic',
      description: 'Get pageview and visitor counts for a site over a date range',
      inputSchema: {
        type: 'object',
        properties: {
          site: { type: 'string' },
          from: { type: 'string' },
          to: { type: 'string' }
        },
        required: ['site', 'from', 'to']
      }
    }
  ]
}))

The pattern that surprised me: structured returns

Way better than raw JSON: return a short natural language summary plus the data. Claude uses the summary for its response and the JSON for follow up questions.

What I did not expect

Users started asking Claude to do things I had not built dashboards for:

• “Compare my paid traffic conversion rate this week vs last week”
• “Which 5 pages had the biggest week over week drop in pageviews”
• “Summarize what changed in my funnel completion rate over the last 30 days”

Claude does this by chaining multiple tool calls. I did not need to build any of those views. The tools are atomic, Claude composes.

This is the part I think is genuinely new about MCP. The interface is the LLM, the backend is just well shaped tools.

Install

npm install -g @zenovay/mcp then add to your Claude Desktop config.

Site: zenovay.com

Open source MCP server work happening here too? Curious what patterns others have found.

Valerio

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

• Android development
• Search experiences
• Firebase workflows
• Cloud tooling
• Flutter applications
• Productivity tools

That changes how we think about software development entirely.

We’re moving from:

• Writing every feature manually

To:

• Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

• Faster backend setup
• Smarter debugging
• Automated app flows
• Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

• Performance improvements
• Better tooling
• Faster iteration cycles
• Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

• UI generation
• Component scaffolding
• Documentation
• Testing
• State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

• Multi-step reasoning
• Context-aware workflows
• Architecture suggestions
• End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

• Designing systems
• Reviewing logic
• Shaping product experiences
• Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

• Product thinking
• User empathy
• Taste
• Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

• ML expertise
• Infrastructure knowledge
• GPU access
• Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

• Writing every system manually

To:

• Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

Last week I shipped a Model Context Protocol (MCP) server for my analytics SaaS. Now Claude Desktop, Cursor, and any MCP compatible client can query traffic, revenue, and funnel data directly.

This is a walkthrough of how I built it, what worked, and a couple of patterns that surprised me.

What MCP is, briefly

MCP is a protocol that lets AI clients invoke tools and read resources from external servers. Think of it as REST for LLM tool calling, with a stable schema and discovery.

Server skeleton

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const server = new Server({
  name: 'zenovay',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
    resources: {}
  }
})

Defining tools

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_traffic',
      description: 'Get pageview and visitor counts for a site over a date range',
      inputSchema: {
        type: 'object',
        properties: {
          site: { type: 'string' },
          from: { type: 'string' },
          to: { type: 'string' }
        },
        required: ['site', 'from', 'to']
      }
    }
  ]
}))

The pattern that surprised me: structured returns

Way better than raw JSON: return a short natural language summary plus the data. Claude uses the summary for its response and the JSON for follow up questions.

What I did not expect

Users started asking Claude to do things I had not built dashboards for:

• “Compare my paid traffic conversion rate this week vs last week”
• “Which 5 pages had the biggest week over week drop in pageviews”
• “Summarize what changed in my funnel completion rate over the last 30 days”

Claude does this by chaining multiple tool calls. I did not need to build any of those views. The tools are atomic, Claude composes.

This is the part I think is genuinely new about MCP. The interface is the LLM, the backend is just well shaped tools.

Install

npm install -g @zenovay/mcp then add to your Claude Desktop config.

Site: zenovay.com

Open source MCP server work happening here too? Curious what patterns others have found.

Valerio

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

• Android development
• Search experiences
• Firebase workflows
• Cloud tooling
• Flutter applications
• Productivity tools

That changes how we think about software development entirely.

We’re moving from:

• Writing every feature manually

To:

• Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

• Faster backend setup
• Smarter debugging
• Automated app flows
• Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

• Performance improvements
• Better tooling
• Faster iteration cycles
• Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

• UI generation
• Component scaffolding
• Documentation
• Testing
• State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

• Multi-step reasoning
• Context-aware workflows
• Architecture suggestions
• End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

• Designing systems
• Reviewing logic
• Shaping product experiences
• Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

• Product thinking
• User empathy
• Taste
• Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

• ML expertise
• Infrastructure knowledge
• GPU access
• Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

• Writing every system manually

To:

• Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

Last week I shipped a Model Context Protocol (MCP) server for my analytics SaaS. Now Claude Desktop, Cursor, and any MCP compatible client can query traffic, revenue, and funnel data directly.

This is a walkthrough of how I built it, what worked, and a couple of patterns that surprised me.

What MCP is, briefly

MCP is a protocol that lets AI clients invoke tools and read resources from external servers. Think of it as REST for LLM tool calling, with a stable schema and discovery.

Server skeleton

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const server = new Server({
  name: 'zenovay',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
    resources: {}
  }
})

Defining tools

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_traffic',
      description: 'Get pageview and visitor counts for a site over a date range',
      inputSchema: {
        type: 'object',
        properties: {
          site: { type: 'string' },
          from: { type: 'string' },
          to: { type: 'string' }
        },
        required: ['site', 'from', 'to']
      }
    }
  ]
}))

The pattern that surprised me: structured returns

Way better than raw JSON: return a short natural language summary plus the data. Claude uses the summary for its response and the JSON for follow up questions.

What I did not expect

Users started asking Claude to do things I had not built dashboards for:

• “Compare my paid traffic conversion rate this week vs last week”
• “Which 5 pages had the biggest week over week drop in pageviews”
• “Summarize what changed in my funnel completion rate over the last 30 days”

Claude does this by chaining multiple tool calls. I did not need to build any of those views. The tools are atomic, Claude composes.

This is the part I think is genuinely new about MCP. The interface is the LLM, the backend is just well shaped tools.

Install

npm install -g @zenovay/mcp then add to your Claude Desktop config.

Site: zenovay.com

Open source MCP server work happening here too? Curious what patterns others have found.

Valerio

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

• Android development
• Search experiences
• Firebase workflows
• Cloud tooling
• Flutter applications
• Productivity tools

That changes how we think about software development entirely.

We’re moving from:

• Writing every feature manually

To:

• Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

• Faster backend setup
• Smarter debugging
• Automated app flows
• Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

• Performance improvements
• Better tooling
• Faster iteration cycles
• Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

• UI generation
• Component scaffolding
• Documentation
• Testing
• State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

• Multi-step reasoning
• Context-aware workflows
• Architecture suggestions
• End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

• Designing systems
• Reviewing logic
• Shaping product experiences
• Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

• Product thinking
• User empathy
• Taste
• Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

• ML expertise
• Infrastructure knowledge
• GPU access
• Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

• Writing every system manually

To:

• Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

• Android development
• Search experiences
• Firebase workflows
• Cloud tooling
• Flutter applications
• Productivity tools

That changes how we think about software development entirely.

We’re moving from:

• Writing every feature manually

To:

• Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

• Faster backend setup
• Smarter debugging
• Automated app flows
• Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

• Performance improvements
• Better tooling
• Faster iteration cycles
• Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

• UI generation
• Component scaffolding
• Documentation
• Testing
• State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

• Multi-step reasoning
• Context-aware workflows
• Architecture suggestions
• End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

• Designing systems
• Reviewing logic
• Shaping product experiences
• Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

• Product thinking
• User empathy
• Taste
• Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

• ML expertise
• Infrastructure knowledge
• GPU access
• Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

• Writing every system manually

To:

• Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.