Every time an entity gets referenced, whether a person, a project, a concept, Mem0 increments a mentions count on that node and its edges. It’s tracked on every update. Written to the database. Never read back. Never used in retrieval scoring. The data’s there, the infrastructure’s there — it just hasn’t been connected yet.

That turned out to be the recurring theme. These codebases are full of good infrastructure and good ideas, often in different places than you’d expect.

I should back up.

Why we did this

We’re building Mneme, a proactive engineering intelligence system, where it watches your team’s signals (commits, PRs, Slack threads, Jira tickets, error spikes, stripe txns) and synthesizes context before decisions get made. To build that, we needed to understand what already exists in the memory space. Blog posts or READMEs only get you so far, so we dove into the actual source code.

So we cloned 10 of the most relevant repos and read through them (read: with some heavy lifting from Claude Code). The list~

1. Graphiti (23K stars),

2. Mem0 (48K stars, $24M raised),

3. Cognee (12.5K stars, $7.5M seed),

4. Letta (21K stars),

5. memU (11K stars),

6. SimpleMem (3K stars),

7. mcp-memory-service (1.4K stars),

8. A-Mem (800 stars),

9. memsearch (612 stars), and

10. claude-cognitive (310 stars)

Over 120K GitHub stars and $31.5M in venture funding aimed at a single thesis: LLMs need persistent memory to be useful.

They’re right about the thesis. The disagreement is about how to get there. And we have obvious bias since we’re building in this space. The research is real, but the interpretation is ours. Keep that in mind.

Three approaches

The approaches fall into three paradigms~

1. System-managed extraction: the system decides what to remember

   1. Mem0, Graphiti, Cognee fall into this bucket: expensive writes, clean output

2. Agent self-management: the agent decides what to remember

   1. Letta’s MemGPT holds its own here - elegant, and depends on agent discipline

3. Compression and retrieval: the system compresses conversation history

   1. SimpleMem, memsearch, mcp-memory-service, claude-cognitive - all trade fidelity for token efficiency

Most production systems will need some mix of all three. But what I found more interesting than the paradigm choices was what happened when I looked at the actual implementations.

What we found when we read the code

The gap between marketing and implementation runs in both directions. Both directions are worth seeing.

Graphiti’s bi-temporal model is as good as advertised. This is from graphiti_core/edges.py:

class EntityEdge(Edge):
    # Edge base class provides: uuid, source_node_uuid, target_node_uuid, created_at
    name: str = Field(description='name of the edge, relation name')
    fact: str = Field(description='fact representing the edge and nodes that it connects')
    fact_embedding: list[float] | None = Field(default=None)
    episodes: list[str] = Field(default=[])
    expired_at: datetime | None = Field(
        default=None, description='datetime of when the node was invalidated'
    )
    valid_at: datetime | None = Field(
        default=None, description='datetime of when the fact became true'
    )
    invalid_at: datetime | None = Field(
        default=None, description='datetime of when the fact stopped being true'
    )

Four datetime fields. valid_at and invalid_at track when a fact was true in the real world. created_at and expired_at track when the system learned and retired the fact. When a new fact contradicts an old one, the old edge gets invalid_at set to the new edge’s valid_at. Nothing is ever deleted. This enables a query you can’t do anywhere else: “What did we know about X at time T?”

Read more

The problem is deceptively simple: when I git push for any of my various open source projects, I would like it routed through my personal account.

And when I push from work, it should use my work email. No manual switching. No “oh crap, wrong email” moments at 2am.

Here’s the setup I landed on. It took a couple minutes and I haven’t thought about it since.

Note: If you’re an SSH person, you can solve this with separate keys and ~/.ssh/config Host aliases but I use HTTPS across machines and prefer leaning on gh’s token management rather than juggling key pairs

The Commit Identity Problem

Git uses a global user.name and user.email from ~/.gitconfig for every commit. If your global config is your work email, every commit across every repo — including your weekend passion project — gets stamped with you@acme.com.

You could set a per-repo override with git config user.email in each project dir, but that’s fragile. You’ll forget (read: I have). You’ll clone a new repo and push three commits before realizing you’ve been committing as the wrong person.

The Fix: includeIf with Remote URL Matching

Git v2.36 introduced hasconfig:remote,1 which lets you conditionally include config files based on the remote URL. This is the key.

First, create a separate config file for your personal identity:

  # ~/.gitconfig-personal
  [user]
      name = Your Name
      email = you@gmail.com

Then add conditional includes to your ~/.gitconfig:

  [user]
      name = Your Name
      email = you@work.com
  [includeIf “hasconfig:remote.*.url:https://github.com/YourPersonalUsername/**”]
      path = ~/.gitconfig-personal
  [includeIf “hasconfig:remote.*.url:git@github.com:YourPersonalUsername/**”]
      path = ~/.gitconfig-personal

That’s it. Any repo with a remote pointing to your personal GitHub org automatically uses the personal identity. HTTPS and SSH both covered. No per-repo config, no directory-based hacks.

The Push / Pull Auth Problem

Solving the commit identity is only half the battle. When you git push, git also needs to authenticate with GitHub. If you use gh (the GitHub CLI), it has its own auth — and it only has one “active” account at a time.

The naive approach: gh auth switch before every push. The correct approach: a custom credential helper that routes automatically.

The Fix: A Custom Credential Helper

Git’s credential system supports custom helpers — scripts that receive the target host and repo path, and return the appropriate credentials. We can write one that checks the repo owner in the URL and picks the right `gh` token:

  #!/bin/bash

  # ~/.local/bin/gh-credential-switcher
  if [ “$1” != “get” ]; then
    exit 0
  fi

  host=”“
  path=”“

  while IFS=’=’ read -r key value; do
    [ -z “$key” ] && break
    case “$key” in host) host=”$value” ;; path) path=”$value” ;;
    esac
  done

  if [[ “$host” != “github.com” ]]; then
    exit 0
  fi

  if [[ “$path” == YourPersonalUsername/* ]]; then
    user=”YourPersonalUsername”
  else
    user=”your-work-username”
  fi

  token=$(gh auth token --user “$user” 2>/dev/null)
  if [ -n “$token” ]; then
    echo “protocol=https”
    echo “host=github.com”
    echo “username=$user”
    echo “password=$token”
  fi

Make it executable chmod +x) and wire it into your ~/.gitconfig:

  [credential “https://github.com”]
      helper =
      helper = !/path/to/gh-credential-switcher
      useHttpPath = true

The empty helper = line clears any previously registered credential helpers (looking at you, macOS Keychain). And useHttpPath = true is critical — without it, git only sends the host to credential helpers, not the repo path, and the script can’t distinguish between orgs.

The macOS Gotcha

If you’re on a Mac, Xcode ships a system-level gitconfig at /Applications/Xcode.app/Contents/Developer/usr/share/git-core/gitconfig that registers osxkeychain as a credential helper. This runs before your custom helper and returns whatever cached credential it has — defeating the entire setup.

The helper = line in [credential “https://github.com”] clears this. If it doesn’t stick (system-level configs can be stubborn), you can also add a global [credential] block:

  [credential]
      helper =
      helper = !/path/to/gh-credential-switcher

Prerequisites

Both GitHub accounts need to be logged into gh:

  gh auth login  # login with your work account
  gh auth login  # login with your personal account

You can verify both are available with

gh auth status

The “active” account doesn’t matter anymore — the credential helper bypasses it entirely.

Verification

Quick sanity check across repos:

# Personal repo
$ git -C ~/projects/side-project config user.email
you@gmail.com

$ git -C ~/projects/side-project ls-remote --heads origin
a1b2c3d  refs/heads/main

# Work repo

$ git -C ~/projects/work-thing config user.email
you@work.com

$ git -C ~/projects/work-thing ls-remote --heads origin
d4e5f6a  refs/heads/main

Different identities, different auth tokens, zero manual switching.

TL;DR

1. Layer

   1. Mechanism

   2. Config

1. Commit identity

   1. includeIf hasconfig:remote

   2. ~/.gitconfig + ~/.gitconfig-personal

2. Push / pull auth

   1. Custom credential helper

   2. ~/.local/bin/gh-credential-switcher

3. macOS Keychain bypass

   1. helper = (clear line)

   2. ~/.gitconfig

4. Path-based routing

   1. useHttpPath = true

   2. ~/.gitconfig

Clone any repo and it just works. New personal project? Personal identity and auth. New work repo? Work credentials. The setup is entirely URL-based, so it doesn’t matter where on disk the repo lives or what branch you’re on.

Ten minutes of config. Months of not thinking about it.

As an engineer, I often find myself sifting through GitHub pull requests, pulling branches down and opening .diffs to review changes. It’s a tedious process to understand the full context and then provide helpful comments. After repeating this for months, why not automate everything with a bookmarklet?

ChatGPT 4o is powerful enough to give me summaries of PRs but selecting all the text on the site isn’t good enough and introduces a lot of clutter. It is much better to provide a diff with appropriate context (like full changed source files) so it can paint a clearer picture.

This also helps when I’ve finalized my own PR and want to provide useful pointers on what’s changed. I feed the diff into the LLM along with the GitHub PR template and it spits out the changes instead of having to manually type it out.

Step 1: The Simple Idea – just open the .diff

GitHub already provides .diff and .patch files for PRs — by appending the extension to the URL, you get the all the changes in a raw format.

javascript:window.open(window.location.href + '.diff');

What if I'm not on a PR page? I also needed the bookmarklet to know when I was on a valid pull request page and act accordingly.

Step 2: Handling Edge Cases (Because I Click Everywhere)

I quickly realized that I’m not always on the "Files changed" tab or even on a valid PR page. Sometimes I’d hit the bookmarklet while still on the main repo, the list of PRs, or even issues tabs. I needed to handle these cases gracefully.

So, I added checks for specific pages like /pulls, /issues, and /actions, displaying an alert if I wasn’t on a valid PR page. That made things a lot smoother:

if (/\/(pulls|issues|actions)|github\.com\/[^\/]+\/[^\/]+$/.test(window.location.href)) {
  alert('You are not on a valid PR page. Please navigate to a specific PR.');
  return;
}

Update: This guard evolved over time while building out the chrome extension to guard against all pages that do not follow the format of —

https://github.com/<repo-owner>/<repo-name>/pull/<number>

Step 3: Adding the "View raw" for Files

Once I had the diff part working, the next natural step was to extend the bookmarklets capabilities by opening each changed file in the pull request. This would be helpful in painting a better picture on how the files related to each other and to create a contextual mind map. The dropdown was just a click away, but why click it manually when I can automate that too?

The script was updated to automatically click the ellipsis buttons for each file, wait for the dropdown to appear, and then click on the "View raw" menu section. Here’s what it ended up looking like:

document.querySelectorAll('.file-header').forEach((fileHeader, index) => {
  const kebabButton = fileHeader.querySelector('.octicon-kebab-horizontal');
  if (kebabButton) {
    setTimeout(() => {
      kebabButton.closest('summary').click();
      setTimeout(() => {
        const viewRawLink = fileHeader.closest('.file').querySelector('a[href*="/raw/"]');
        if (viewRawLink) window.open(viewRawLink.href, '_blank');
      }, 500);
    }, index * 1000);
  }
});

Learnt the preferred nomenclature is kebab not ellipsis. Now the bookmarklet could handle both the .diff file and individual "View raw" links for all files in the "Files changed" tab.

The final code

javascript:(function() {
  const prUrl = window.location.href;

  // List of invalid URL patterns (main page, /pulls, /issues, /actions)
  const invalidPatterns = ['/pulls', '/issues', '/actions', /github\.com\/[^\/]+\/[^\/]+$/];

  // Check if the URL matches any invalid patterns
  if (invalidPatterns.some(pattern => prUrl.match(pattern))) {
    alert('You are not on a valid PR page. Please navigate to a specific PR.');
    return;
  }

  // Part 1: Open the diff file after extracting base PR URL
  const normalizedUrl = prUrl.split('/pull/')[0] + prUrl.match(/\/pull\/\d+/)[0]; // Extract base PR URL
  const diffUrl = normalizedUrl + '.diff';
  window.open(diffUrl, '_blank');

  // Part 2: If not on the "Files changed" tab, exit after opening the diff
  if (!prUrl.includes('/files')) {
    return;
  }

  // Part 3: If on the "Files changed" tab, open the "View raw" links
  const fileHeaders = document.querySelectorAll('.file-header');

  function openRawView(fileHeader) {
    const kebabButton = fileHeader.querySelector('.octicon-kebab-horizontal');

    if (kebabButton) {
      // Click the ellipsis button to open the dropdown
      kebabButton.closest('summary').click();

      // Wait for the dropdown to appear, then click "View raw"
      setTimeout(() => {
        const viewRawLink = fileHeader.closest('.file').querySelector('a[href*="/raw/"]');
        if (viewRawLink) {
          window.open(viewRawLink.href, '_blank');
        } else {
          console.error('Could not find the "View raw" link.');
        }
      }, 500); // Delay to allow the dropdown to appear
    } else {
      console.error('Could not find the kebab button.');
    }
  }

  // Loop through each file header, trigger the process for "View raw"
  fileHeaders.forEach((fileHeader, index) => {
    // Stagger the openings to prevent overload
    setTimeout(() => openRawView(fileHeader), index * 1000);
  });
})();

And a One-Liner Bookmarklet

javascript:(function(){const prUrl=window.location.href;if(/\/(pulls|issues|actions)|github\.com\/[^\/]+\/[^\/]+$/.test(prUrl)){alert('You are not on a valid PR page. Please navigate to a specific PR.');return;}const diffUrl=prUrl.match(/\/pull\/\d+/)?prUrl.split('/pull/')[0]+prUrl.match(/\/pull\/\d+/)[0]+'.diff':null;if(diffUrl)window.open(diffUrl,'_blank');if(!prUrl.includes('/files'))return;document.querySelectorAll('.file-header').forEach((fileHeader,index)=>{const kebabButton=fileHeader.querySelector('.octicon-kebab-horizontal');if(kebabButton){setTimeout(()=>{kebabButton.closest('summary').click();setTimeout(()=>{const viewRawLink=fileHeader.closest('.file').querySelector('a[href*="/raw/"]');if(viewRawLink)window.open(viewRawLink.href,'_blank');},500);},index*1000);}});})();

You can add this by either

1. using this website or

2. bookmarking this site, changing the name to GH - ChatGPT or any equivalent, editing the bookmark and pasting the one-liner above in the URL section

Remember to always allow pop-ups when using this for the first time and try not use this on PRs with many files changed, it’ll open a bunch of tabs.

Another one - Opening a ChatGPT chat programmatically

If you don’t want to copy the contents of the diff into ChatGPT you can run this bookmarklet which opens a new chat. You do need an account —

Code

(function() {
  const prUrl = window.location.href;

  // Check if the URL contains ".diff" to ensure it's a valid diff page
  if (!prUrl.includes('.diff')) {
    alert('This bookmarklet only works on .diff pages.');
    return;
  }

  // Get the contents of the diff file
  const diffContent = document.body.innerText;

  // Create the prompt for ChatGPT, broken into multiple lines for readability
  const prompt = encodeURIComponent(
    `You are an expert programmer in React Native and Python. I've provided a diff file.\n\n` +
    `I want you to summarize the changes and provide any helpful comments, feedback, fixes, and optimizations that can be done to the code to make it better in bullet points.\n\n` +
    `I can also provide the files if needed, let me know.\n\n` +
    `Here is the diff:\n\n${diffContent}`
  );

  // Open ChatGPT with the pre-filled prompt
  window.open(`https://chatgpt.com/?q=${prompt}`, '_blank');
})();

And a One-Liner Bookmarklet

javascript:(function(){if(!window.location.href.includes('.diff')){alert('This bookmarklet only works on .diff pages.');return;}const prompt=encodeURIComponent(`You are an expert programmer in React Native and Python. I've provided a diff file. I want you to summarize the changes and provide any helpful comments, feedback, fixes, and optimizations that can be done to the code to make it better in bullet points. I can also provide the files if needed, let me know.\n\n${document.body.innerText}`);window.open(`https://chatgpt.com/?q=${prompt}`,'_blank');})();

Same instructions as above to create a bookmarklet. Happy Friday!

Chrome Extension

Adding bookmarklets is tough. I created a chrome extension that streamlines the workflow for interacting with GitHub pull requests. This tool allows one to quickly open diff files, access raw files, and even send pull request diffs to ChatGPT for feedback—all with the click of a button! The extension is built with TypeScript for type safety and leverages Chrome's powerful scripting and activeTab permissions to interact directly with the GitHub page.

The best part? The tool is fully customizable! I added an editable prompt feature for ChatGPT, so one can fine-tune the kinds of feedback they’re seeking. From improving code quality to reviewing changes more efficiently, this extension has been a game changer in my development workflow. If you prefer a GUI, there is an open source chrome extension available here —

• https://github.com/VirenMohindra/github-diff, and here

• https://chromewebstore.google.com/detail/github-diff/hhopppbhdogliepfdaihcoicedlieibn

If he writes her a few sonnets, he loves her. If he writes her 300 sonnets, he loves sonnets

if you want to size up a distributor, a quick way is one truck or trailer is equivalent to a million in revenue

Read more

Read more

Premise

Sports books in America are synonymous to the credit card companies of yesteryear. They’re looking to capture the largest market share in the least amount of time, and are willing to cut into their massive profits to make the onboarding process easier.

This aggressiveness lends them to providing outrageous sign up bonuses for first time users, and follow up bonuses so you don’t churn away. Let’s take a look at our players.

1. BetMGM - There are many benefits when you’re working with quite possibly the worst sportsbook user interface. Their

2. Fanduel - $3000 promo for Super Bowl. I’ve churned this twice for a neat 1.6K profit. My accounts been marked as a whale with my weekly turnover.

3. Hard Rock Casino - Can’t multi state bet which sucks since I really enjoyed turning a tidy profit on Alcaraz’s game.

4. Caesar’s - we’ll touch on this beauty later.

A conversation

Read more

Unanticipated Service Downgrades and Billing Confusion: Our journey into the abyss began with an unexpected downgrade in our Pro Bundle Plan. No communication, no email alerts – just a sudden change that we stumbled upon. This wasn't just an oversight; it reflected a deeper problem in transparency and customer communication within Magic.

The Domino Effect on Our Services: This downgrade triggered a loss of auto-refresh magic sessions. Imagine our shock when this led to a month-long (and counting) disruption of service for all our users. An app-breaking issue, stemming from a change we weren't even informed about!

Quick Fixes, Lingering Problems: Magic's response, while prompt, was akin to placing a band-aid on a gaping wound. The fixes resolved nothing substantial, leaving us to grapple with TypeScript issues and untested Expo packages. Our engineering team spent precious time scouring GitHub issues, trying to discern if the problem was on our end or Magic's. Spoiler alert: it was on Magic's.

Wasted Resources and Stalled Development: The fallout was immense. We burned through a long weekend and three full working days, troubleshooting, attending calls, and reporting issues – all to no avail. Our development cycle ground to a halt, as Magic's issues blocked us from pushing out new builds.

Reluctance to Change, Despite Discontent: Staying with Magic wasn’t a choice driven by satisfaction but a lack of bandwidth to switch providers or develop our own authentication solution. This is a crucial point for startups to consider – sometimes the devil you know seems better than the devil you don't.

Support Channels: A Labyrinthine Endeavor: Seeking support from Magic turned into a Herculean task. Immediate help was a myth; we were funneled into scheduled calls and endless back-and-forths, leading nowhere but to increased frustration.

A Broken Website Experience: To add insult to injury, Magic's website was a nightmare. A non-functional search feature, a user export request that took months to implement (and still underperforms), and the inability to perform basic sorting – it was less magic and more tragic.

Conclusion: A Call for Accountability and Change: This post isn't just a venting session but a call to action. Service providers like Magic must understand the gravity of their shortcomings and the ripple effect on their clients' businesses. As for fellow entrepreneurs and tech enthusiasts, let this be a reminder to continuously evaluate your service providers, demand transparency, and always have a contingency plan.

In the end, the magic we seek in technology services lies not in grand promises but in reliability, effective communication, and a commitment to problem-solving. It's time for Magic to step up their game or step aside.

The optimal use case is when you have access to OTA and can target prior versions to upgrade backend endpoints so that everyone is pushed to the latest version. With expo this fairly easy and can be run with this command

eas update --branch production -p ios

Code snippet below -

// your various imports here

// constants
const LATEST_VERSION = '2.2.8'
const LATEST_VERSION_NUMBER = Number(STABLE_VERSION.split('.').join(''))
const appStoreName = 'gently-shop-fashion-deals'
const appStoreId = 'id6450376418'
const appStoreURL = `itms-apps://apps.apple.com/id/app/${appStoreName}/${appStoreId}?l=id`

const Root = () => {
  const ver = Number(Constants.expoConfig.version.split('.').join(''))

  if (ver < LATEST_VERSION_NUMBER) {
    Alert.alert(
      'New Update Available',
      'For the best experience and new features, please update your app now.',
      [{ text: 'Update Now', onPress: () => Linking.openURL(appStoreURL) }]
    )
  } else
    return (
      <SessionProvider>
        <HomeStateProvider>
          <GlobalStateProvider>
            <StripeProvider
              publishableKey={STRIPE_PUBLISHABLE_KEY}
              urlScheme="gently"
              merchantIdentifier="merchant.com.gently"
            >
              <ThemeProvider theme={theme}>
                <Toast>
                <App />
              </ThemeProvider>
            </StripeProvider>
          </GlobalStateProvider>
        </HomeStateProvider>
      </SessionProvider>
    )
}

A simple explanation of the constants for the uninitiated

1. LATEST_VERSION: This will be the minimum semver in a string format. Any version below will be forced to update, i.e. a user still on v2.6.0 will see the non-dismissible Alert dialog if the latest app version is v2.8.0.

2. appStoreName, appStoreId: You can find these when visiting your app URL and copying it over. Various resources available.

1. Singularity, Eliezer S. Yudkowsky, 18 Nov, 1996.

2. How To Become A Hacker, Eric Steven Raymond, 4 Oct, 2007.

3. How to Drop Out, Ran Prieur, 2 Apr, 2004.

4. An Open Letter To Open-minded Progressives, Mencius Moldbug, 17 Apr, 2008.

5. The Metamorphosis of Prime Intellect, Roger Williams, 14 Oct, 2003.

Singularity

Eliezer S. Yudkowsky's "Singularity" essay from 1996 is one of the early writings on the concept of the technological singularity.

Read more

Read more

If you’re looking to raise money for your prototype (not idea!), I would love to chat. Please send me a link to what you’ve built and a few sentences on you and why you built it: viren@mohindra.fund

Website Link: Mohindra Fund

There are few criteria that I am unwilling to compromise on

1. Standard check sizes ranging from $5-10k

   • I can’t do less and I can’t do more at this time.

   • For 2023, I’m planning on cutting a minimum of 20 checks and maximum of 40.1

2. I only invest in domains I have some familiarity with and am a value-add

   • Fintech, and B2B SaaS, Agritech are my personal preferences (in that order).

3. Founder - Investor fit is imperative

   • Yes, the idea and execution, but I only invest in founders I would work for.

4. They’re written off the second the wire hits your account

   • A double-edged sword: this does not mean I’m averse to advising you in larger capacity — I’m instead committed to the cause and growth of your company and do not want monetary incentivization to introduce decisions bias.

5. Deck is optional, prototype isn’t

   • I do not care for the TAM, but you’ve got my attention if you have something I can play around with.

6. If you’ve already raised and have lawyers handling the agreements, I’m open to working with them. Otherwise —

   • I have standard agreements which are pro-founder and are battle-tested.2

7. A safety net is fine for the most part

   • There is no need (or rush) to quit your full-time job but once you’re fully allocated there is an expectation to pursue this properly.

8. One can expect (and should expect) to be allocated up to 250K from my network

   • I can and will help with fundraising your pre-seed and complete allocation.

9. I can’t and won’t help with everything (and nor should I)

   • Setting expectations is important.

10. I don’t mind or care for big names on the cap table.

    • I’ll be as hands off or on depending on the domain and founder need.

11. Once the diligence process kicks off, I prefer to close in less than 60 days

    • Barring any complications — which there really shouldn’t be at this stage anyway

12. Monthly updates are optional, communication is required

    • I index on the primary founder, and check for

      • willpower

      • intelligence

      • thoughtfulness

      • appropriate greed

      • appropriate discipline

      • high velocity

      • daily expectations

      • ability to attract S-tier team3

References available on request

Read more

Read more

Brain Drain

I have had the chance to renege my Indian passport on a number of occasions, the earliest when I resided in Singapore, and then in Hong Kong. Lion City was an easy decision, they require mandatory conscription and even though they hold a strong passport, I am not willing to serve any country besides my own. While I hold a permanent residency in HK, replacing it with my motherland also doesn’t solve my main concerns, notably having access to purchase land under my own name.

Some of the more novel ideas I’ve been working on for the past few years require me to own farmland in India and without the status I am left to rely on others for help.

I’ve bifurcated my projects into a few overarching categories:

Food Security

Growing world population threatens future food and feed security as natural resources are currently being over exploited. FAO estimates that commercial feed production needs to increase by 70% in the next 30 years to meet the growing demand for protein. This increase of demand has forced the price of fishmeal to increase in land sustainable innovations are critical to combat this issue. Insect feed farms have risen up to combat this issue and has made them extremely attractive for various livestock production systems.

Producing insect proteins as an alternative to the fish and soybean meal that currently dominates the market can be made at roughly 60-70% of production costs. Fishmeal production as feed is currently unsustainable and has lead to the collapse of many fisheries and now is being considered too expensive to use in most farm animal diets.

Read more

TechCrunch | Fortune Term Sheet | Fashion Network

It’s been a while since I dropped a watch post and a whole four months since I picked up my latest watch. I’m back in Delhi which means I have time to push out content since half my free time will likely be spent in hour-long traffic and what better way to utilize that by jotting down some notes for my blog. In this writeup, I’ll touch upon my reasoning for purchasing the Omega Seamaster Aqua Terra Golf, how it fits into my rainbow collection, how I missed the opportunity to pick up a Grand Seiko, and why gatekeeping the horological industry is an inane and fruitless endeavor (specifically the Swatch incident/ collaboration).

Read more

Boris Johnson had had a long day. Countless meetings, appraisals, and bills were stacked high upon his desk. He was in no mood for squabble, but took some time out to play the latest Wordle. While deciding between CRANE and ADIEU, the first two notes of Satie's Gnossienne 5 (but two semi-tones lower — C, F instead of D, G) played abruptly, leaving a ringing noise in ol’ Bojo’s ear. For the uninitiated, this was also the Gmail Notification sound on iOS. Unlike his ex-US counterpart, Mr. Johnson was fully prepared to make the switch from Blackberry to iPhone.

Read more