Isaiah 60:10–11

“Foreigners will rebuild your walls, and their kings will serve you. Although I struck you in anger, yet in favour I will show you mercy. 11 Your gates will always stand open; they will never be shut, day or night, so that the wealth of the nations may be brought to you, with their kings being led in procession.”

Happy New week!

Founders should get their product in front of customers as fast as possible, even if it’s imperfect. The purpose of raising investment is not to start building the product, but to accelerate something that is already showing real momentum.

When customers are actively trying, using, or even struggling with a rough version of your product, it signals urgency. It shows that the problem is real, the solution is needed now, and people are willing to engage despite the product being “shabby.”

That urgency is what makes investors pay attention. They’re not betting on a polished interface; they’re betting on demand and velocity.

Shipping early does three critical things:
— It validates whether your idea is solving a real problem or just a compelling story in your head.
— It creates momentum through early usage, feedback, and iteration.
— It makes your startup investable by proving there is a path to a real go-to-market motion.

If you wait to make the product “perfect,” you delay learning and you delay proof of demand. A rough product in the hands of real users is far more valuable than a beautiful product with no customers.

Investors don’t invest in ideas alone.
They invest in evidence:
— Evidence that a problem exists
— Evidence that people care
— Evidence that there is traction, urgency, and a clear path to market

Getting your product out early is how you turn a belief into a business and an idea into something investable.

Someone once told me my life seemed boring because of all my routines and discipline. But to me, these very habits are the reason I thrive. They are acts of self-respect, the backbone of my ethics, and the reason I am selective. Discipline doesn’t restrict me; it empowers me.

Some founders will do literally anything… except sales.

They’ll:

- Build the product for the 1000th time

- Redesign the landing page (again)

- Do more market research

- Ask ChatGPT for positioning, ICPs, taglines, objections, counter-objections

- Raise money

- Pitch VCs

- Pitch again

But actually go sell?

Absolutely not.

Sales is awkward.

Sales involves hearing “no.”

Sales risks discovering the product isn’t as brilliant as we hoped.

So we stay busy instead.

Product work feels noble.

Research feels responsible.

Fundraising feels prestigious.

Sales feels… personal.

And yes…fear of rejection is definitely part of it.

Not rejection of the product.

Rejection of you.

The irony?

You’ll happily get rejected by 97 VCs…

…but avoid 10 customer conversations like it’s emotional lava.

If you’re avoiding sales, it’s not a strategy problem.

It’s an identity problem.

let me tell you about a little story from about 8 months ago.

i’m sitting across from my friend at a coffee shop after she came back from her vacation.

she’s telling me about this trip she took to iceland. waterfalls, northern lights, the whole thing.

i’m nodding along, showed interest, asking questions. you know what people normally do during a conversation right.

but halfway through her story, i realize i haven’t actually heard a single word she’s said for the last two minutes.

because i’ve been thinking about my phone. it’s in my pocket. i can’t see it. but i can feel it.

before she really started breaking down her trip, i heard a ping and felt that pull. that magnetic draw. that quiet voice saying “check me, something might be there.”

i catch myself reaching for it mid-conversation. stop myself. put my hand back down.

five minutes later, i’m doing it again.

my friend doesn’t notice. or maybe she does and she’s used to it. we all do this now.

we’re present but not really. here but somewhere else. listening but not hearing.

and i’m thinking, when the fuck did this happen? when did a device become more interesting than a real person sitting in front of me?

when did my brain start preferring the possibility of a notification over an actual human connection?

when did i lose the ability to just… be present?

8 months ago that’s all i could think

i remember being a kid and getting completely absorbed in things. building lego for hours, lost in it. reading books and forgetting time existed. having conversations that felt infinite.

i remember when the world felt vivid. when colors seemed brighter, when experiences felt fuller, when moments stretched out instead of blurring together.

somewhere between then and now, something changed.

and i blamed it on growing up. on responsibilities. on “that’s just life.”

but sitting there, fighting the urge to check my phone while my friend talks about fucking waterfalls, i realize: it’s not life. it’s the device.

my brain had been hijacked. rewired. reprogrammed to prefer digital stimulation over reality.

and i knew i wasn’t alone with that feeling. i knew people felt it. i know you feel it too.

that constant low-level anxiety when your phone isn’t within reach. that compulsion to check it even when you know there’s nothing there. that sense that real life has become somehow… less.

less interesting. less colorful. less engaging than the little glowing rectangle.

fast forward 8 months later, and the spark in me has been reignited. after countless hours of research and endless motivation to get to the bottom of this, i found it.

so let me break down exactly what’s happened to your brain, why you can’t stop, and what it’s costing you.

a cup of black coffee sitting next to me. in this 10 minute read i will fundamentally change how you see your phone forever, and maybe, just maybe i can help you beat your addiction. i’m not promising but reading this will definitely be a nudge in the right direction.

let’s get into this.

THE SLOT MACHINE IN YOUR POCKET

“Technology is a useful servant but a dangerous master.” — Christian Lous Lange

your phone is a casino.

and you’re the gambler who can’t leave the table.

every time you pick it up, you’re pulling a lever on a slot machine. will there be a notification? a like? a message? something interesting?

what’s going to spike my dopamine now?

you don’t know. and that uncertainty is what makes it addictive.

this is called a variable ratio reward schedule, and it’s the most addictive reinforcement pattern known to psychology.

slot machines use it. so do phones.

you pull the lever (unlock your phone) and sometimes you get a reward (notification, interesting content) and sometimes you don’t (nothing new).

but because you can’t predict when the reward will come, you keep checking.

because the next check might be the one. the next refresh might have something.

your brain releases dopamine not just when you get the reward, but in anticipation of potentially getting it.

and that anticipation keeps you hooked.

here’s the neurology: your ventral tegmental area (VTA) releases dopamine when you anticipate reward.

this dopamine travels to your nucleus accumbens, which processes reward and motivation.

when the reward is uncertain, dopamine release is actually higher than when it’s guaranteed.

uncertainty creates more craving than certainty.

this is why you can’t stop checking your phone even when you consciously know there’s probably nothing there.

your brain is chasing the dopamine hit from the possibility of a reward.

and tech companies know this. they engineer it deliberately.

infinite scroll means there’s always potentially something interesting just one more swipe away.

variable notification timing means you never know when something will come in, so you have to keep checking.

the red notification badge creates urgency and triggers checking behavior.

pull-to-refresh mimics the physical action of a slot machine lever.

every element is designed to exploit your dopamine system and keep you engaged.

you’re not weak for being addicted. you’re up against billions of dollars of neuroscience research optimized to hijack your brain.

social media has perfected this with it’s short form content algorithm. just know if something is free, you are usually the product.

THE HYPERSTIMULATION TRAP

your phone produces more sensory intensity than anything in the natural world.

colors more saturated than flowers. sounds more varied than birdsong. movement faster than anything you’d see outside.

your screen can display millions of colors. shift between them instantly. flash them at frequencies designed to grab attention.

this is hyperstimulation. and your brain adapts to it by raising the threshold for what counts as interesting.

it’s like living in a house with a constant loud noise. eventually you stop hearing it. your auditory system adapts by becoming less sensitive.

same thing happens with your visual and reward systems.

after hours of bright, colorful, fast-moving content on your phone, real life looks gray by comparison.

literally. your color perception dulls because your brain has recalibrated to expect digital intensity.

you always hear people say “life used to be brighter when we were kids” or “the world has gone dull”. yes our bodies do naturally see the world as ‘less colorful’ as we age but your phone amplifies it to a degree you couldn’t even imagine.

your phone is the reason why sunsets that used to take your breath away now barely register.

your phone is the reason why conversations feel slow and boring.

your phone is the reason why books feel like too much effort.

your phone is the reason why you can’t just sit and exist without feeling understimulated.

your baseline for “interesting” has been artificially inflated to a level that reality can’t compete with.

and the more you use your phone, the worse this gets.

you need more and more stimulation to feel the same level of engagement. this is tolerance. the same mechanism as drug addiction.

you’re building tolerance to normal life.

THE FEAR OF MISSING OUT IS PRIMAL

“In a world of algorithms, hashtags and followers, know the true importance of human connection.” — Simi Fromen

FOMO isn’t just a millennial buzzword. it’s an evolutionary mechanism being weaponized against you. humans evolved in small tribes where social exclusion meant death.

if you weren’t aware of what the group was doing, you could miss critical information, lose status, or get left behind.

so your brain developed hypervigilance for social information.

what are others doing? what are they talking about? am i included? am i valued?

these questions determined survival for thousands of years.

your phone hijacks this ancient system.

every notification is a potential social update. every scroll might reveal what you’re missing.

and because social media shows you everyone’s highlights simultaneously, you’re constantly seeing things you’re not part of.

your friends having fun without you. events you weren’t invited to. experiences you’re not having.

your amygdala, which processes social threat, lights up.

your brain interprets this as social exclusion, which triggers the same pain circuits as physical pain.

this hurts. literally. brain scans show social rejection activating pain centers.

so you keep checking to make sure you’re not missing anything, which exposes you to more evidence of things you’re missing, which makes you check more.

it’s a feedback loop designed to keep you engaged.

but here’s what’s fucked up: FOMO is based on a lie.

you’re not actually missing out. you’re experiencing missing out.

there’s a difference.

missing out means you’re present in your own life but not in someone else’s highlight reel.

experiencing missing out means you’re not present in your own life because you’re too busy watching other people’s.

the irony is that the more you try to avoid FOMO by staying connected, the more you actually miss out on your own life.

you miss the sunset because you’re watching someone else’s sunset on instagram.

you miss the conversation because you’re checking what other conversations are happening.

you miss your life scrolling through other people’s lives.

TIME DISTORTION & DISSOCIATION

you pick up your phone to check one thing.

next thing you know, an hour is gone. where did it go? you barely remember what you looked at. this is time distortion, and it’s a feature.

your phone is designed to put you in a flow state, but not the productive kind.

it’s a dissociative state where your prefrontal cortex, which tracks time and maintains self-awareness, goes offline.

you become absorbed in the feed. scrolling, swiping, consuming content without conscious deliberation.

your brain shifts from executive control to autopilot. and in autopilot mode, time stops being tracked.

studies show people consistently underestimate how much time they spend on their phones by 50% or more.

you think you scrolled for 10 minutes. it was 30.

this happens because your hippocampus, which creates episodic memories, isn’t fully engaged during mindless scrolling.

you’re not encoding distinct memories. you’re in a state of continuous partial attention. you’re paying just enough attention to process each piece of content but not enough to encode it into long-term memory.

real quick tell me the last 5 tiktok videos you watched, or instagram reels you watched? you probably can’t right.

when you try to remember what you just spent an hour doing, there’s nothing there. your brain compressed it all into a vague blur because nothing was significant enough to remember.

this is time theft. hours of your life disappearing into a void with nothing to show for it. if this doesn’t scare you, i don’t know what will. ask any old person what they regret doing and they will probably say ‘wasting time’

mind you they didn’t even have phones.

it’s not just wasted time. it’s also fragmenting your attention in ways that persist even when you’re not on your phone.

ATTENTION FRAGMENTATION

“The smartphone has become a symbol of our increasingly fragmented attention.” — Nicholas Carr

every time you check your phone, you’re interrupting whatever you were doing.

your brain has to switch contexts. disengage from the current task, process the phone content, then try to re-engage with the original task.

this is called context switching, and it’s cognitively expensive.

research shows it takes an average of 23 minutes to fully refocus after an interruption.

but most people check their phones every 12 minutes.

which means you never actually achieve deep focus. you’re constantly in a state of partial attention.

this destroys your ability to do complex cognitive work. writing, deep thinking, problem-solving, creative work, all of this requires sustained focus.

but your brain has been trained to expect interruption every few minutes. so even when your phone isn’t actively in your hand, your attention is fragmented.

you’re anticipating the next check. the next notification. the next hit of stimulation.

this is called “continuous partial attention” and it’s become the default state for most people. you’re never fully present anywhere. always half-engaged, half-waiting for the next digital input.

and over time, this rewires your brain.

your anterior cingulate cortex, which controls attention and impulse control, physically shrinks. your ability to sustain focus degrades.

you become neurologically incapable of the kind of deep work that creates value and meaning.

and you wonder why you can’t focus on books anymore. why conversations feel exhausting. why you can’t finish projects.

it’s not you. it’s your fragmented attention system that’s been systematically destroyed by constant phone use.

PHONES REPLACE MEANING WITH STIMULATION

something shifted in the last decade and most people haven’t noticed it yet.

we used to create things. write, build, make, do. now we mostly consume. and consumption feels productive. scrolling feels like learning. watching content feels like connecting.

but there’s a difference between stimulation and meaning that your brain doesn’t naturally distinguish.

stimulation is short-term dopamine hits. eating candy, scrolling feeds, watching entertainment, getting likes.

meaning is long-term fulfillment from actually building something. creating work you’re proud of, developing real relationships, making progress on goals that matter.

psychologists call these hedonic pleasure versus eudaimonic well-being.

your brain needs both. but it evolved to prioritize hedonic pleasure in the moment because it’s immediate and certain.

your phone exploits this by offering infinite hedonic hits with zero eudaimonic payoff.

you get the dopamine. you don’t get the fulfillment.

seriously think about it. you can scroll for three hours and feel nothing afterwards except vaguely guilty and tired.

but you can work on something meaningful for 30 minutes and feel energized for hours.

yet your brain keeps choosing the scroll. why?

because the phone offers guaranteed dopamine right now. the meaningful work offers possible fulfillment later, after effort and uncertainty.

and over time, you stop pursuing meaningful activities entirely because they can’t compete with immediate gratification.

writing a book takes months of effort with no dopamine hits along the way.

scrolling twitter gives you dopamine every 10 seconds. your brain learns to prefer the latter even though it leaves you empty.

building a real relationship requires vulnerability, effort, showing up consistently through uncertainty.

watching relationship content on your phone requires nothing and gives you the illusion of connection without the risk.

your brain learns to prefer the simulation over the real thing.

this is how people end up feeling empty despite being constantly stimulated.

they’ve replaced meaning with stimulation. depth with breadth. quality with quantity and stimulation without meaning is just noise. it’s junk food for your brain. fills you up temporarily but leaves you malnourished.

THE DREAM YOU’RE LOSING

“The things you own end up owning you.” — Chuck Palahniuk

you have goals. dreams. things you want to create or become.

but you’re not making progress and you blame discipline. motivation. circumstances.

but the real reason is simpler your phone is stealing the time and attention you need to pursue those dreams.

every hour scrolling is an hour not spent on your craft.

every fragmented attention span is cognitive capacity you can’t bring to complex work. every dopamine hit from likes is reducing your motivation to do hard things that actually matter.

you’re trading your potential for digital stimulation.

and the worst part is it doesn’t feel like a trade. it feels like nothing.

because the cost is invisible. it’s gradual and cumlative.

you don’t notice that you’re not writing the book. you just notice you never have time.

you don’t notice that you’re not building the business. you just notice you’re too tired.

you don’t notice that you’re not deepening your relationships. you just notice you feel alone.

the phone isn’t obviously preventing you from doing these things. it’s just quietly stealing the resources you need to do them.

and years pass. and the dreams stay dreams. and you wonder what happened.

what happened is you chose stimulation over meaning. repeatedly. daily. hourly.

and now you’re 5 years older with nothing to show for it except a higher screen time average.

THE FRAMEWORK: HOW TO TAKE YOUR BRAIN BACK

alright, you understand the mechanism, you see how you’ve been hijacked. now what?

like i mentioned before, i can’t promise you that you will break your phone addiction but i can give you pieces of actionable advice that helped me.

this is not a step-by-step tutorial, it doesn’t work like that.

you need to recalibrate your dopamine system and rebuild your attention capacity.

this isn’t about deleting all apps and going full minimalist. that’s unrealistic for most people.

this is about strategic intervention to break the addiction patterns while maintaining functionality.

create physical barriers

your phone should not be the first thing you see when you wake up or the last thing you see before sleep.

charge it in a different room. buy an alarm clock if you need to.

those first and last hours of the day should belong to your brain, not your device.

remove social media apps from your phone. you can still access them on desktop, but adding friction reduces compulsive checking.

turn off all non-essential notifications. most of what pings you can wait.

the most important one though is to use grayscale mode. this removes the color intensity that hijacks your visual system. your phone becomes less stimulating immediately.

time-box your usage

you don’t have to quit your phone. you have to contain it.

designate specific times for checking social media. 30 minutes at lunch, 30 minutes in the evening, whatever works.

outside those windows, it doesn’t exist.

use app timers to enforce this. most phones have built-in tools to limit daily usage per app.

when you hit the limit, that app locks for the day. no negotiation.

replace phone time with presence time

this is critical. you can’t just remove the phone without replacing it with something else.

your brain needs stimulation. give it natural stimulation.

go outside without your phone. walk. sit. observe.

at first it will feel boring. that’s withdrawal. push through. check out my post on how to rewire your brain for more information on what ‘pushing through’ will do.

gradually, your brain will recalibrate to find natural stimuli interesting again.

colors will start to return. sounds will become noticeable. the world will regain texture.

rebuild your attention span

start with 10 minutes of focused work without checking your phone.

just 10 minutes. no multitasking. no switching. pure focus on one task.

do this daily and gradually increase the duration. it’s as simple as that

your anterior cingulate cortex will physically rebuild its capacity for sustained attention.

but it takes time. weeks, maybe months. be patient with the process.

rediscover boredom

boredom is not the enemy. understimulation is not a problem to solve.

boredom is when your brain does its best thinking. when creativity emerges. when you process emotions and experiences.

when you fill every moment with phone content, you never give your brain space to think.

deliberately create boredom. sit in waiting rooms without your phone. stand in lines without distraction.

let your mind wander. it knows what to do.

pursue meaning over stimulation

every day, do one thing that contributes to a meaningful goal.

write 500 words. code for 30 minutes. practice an instrument. have a real conversation.

something that builds toward who you want to become.

this creates eudaimonic reward. and over time, your brain learns to value this deeper satisfaction over shallow stimulation.

but you have to consistently choose it. daily. until it becomes the pattern your brain expects.

track your progress

your brain needs evidence that things are changing.

use screen time tracking. watch the numbers go down over weeks.

journal about what you notice. colors becoming brighter. focus improving. time feeling less distorted.

this creates a positive feedback loop. you see progress, which motivates continued effort, which creates more progress.

THE CHOICE

“Almost everything will work again if you unplug it for a few minutes, including you.” — Anne Lamott

look, i’m not going to sugarcoat this. breaking phone addiction is hard. probably the hardest fucking thing you will do in your life.

your brain will resist. you’ll feel anxiety when you can’t check. you’ll feel FOMO. you’ll feel bored.

that discomfort is your dopamine system recalibrating. it’s supposed to hurt.

most people won’t do it. they’ll read this, feel inspired for an hour, then go right back to their patterns. i don’t blame them either but i know this post will change at least 1 persons life and that’s all that matters. whether that person is you or not, is up to you.

addiction is easier than discipline. stimulation is easier than meaning. distraction is easier than presence.

but you’re not most people.

you can feel something is missing. you remember what it was like to see the world in full color.

you want that wonder back. you want your attention back. you want your life back.

and now you know how to get it.

but it requires a choice. screens or sunsets. notifications or nature. artificial stimulation or authentic presence.

you can’t have both. not at the intensity your brain has been trained to expect.

you have to choose. and you have to choose now.

because every day you delay is another day the world loses more color. another day wonder dies a little more. another day you become more numb to the beauty surrounding you.

the children you see playing outside? they can still see the magic. the colors are still vivid to them. the world is still full of wonder.

but they’re getting phones younger and younger. and their wonder is being systematically destroyed. just like yours was.

unless you break the cycle. unless you remember what it means to be present. unless you choose to see the world with your own eyes instead of through a screen.

the colors are still there. the wonder is still there. the magic is still there.

your dreams are still there.

you just forgot how to see them.

but you can remember.

if you’re willing to put down your phone and look up.

thank you for reading until this point, i appreciate you taking the time out of your day for reading this stuff it truly means a lot and i hope my posts provide you some value.

1. Node.js installation (https://nodejs.org)
2. Environment that can run a localhost web server

Using the sample

1. Navigate to this folder
2. Run npm install to download a small number of dependency packages (see package.json)
3. Run npm run dev to start the web server, navigating any firewall permissions prompts
4. Use any of the provided URIs from the console output, e.g. http://localhost:5173/, in a browser
5. In the “Endpoint” field, provide the resource endpoint of an Azure OpenAI resource; this does not need to append /realtime and an example structure might be https://my-azure-openai-resource-from-portal.openai.azure.com
6. In the “API Key” field, provide a corresponding API key
7. Click the “Record” button to start the session; accept any microphone permissions dialog
8. You should see a << Session Started >> message in the left-side output, after which you can speak to the app
9. You can interrupt the chat at any time by speaking and completely stop the chat by using the “Stop” button
10. Optionally, you can provide a System Message (e.g. try “You always talk like a friendly pirate”) or a custom temperature; these will reflect upon the next session start

in your src

add the following code

main.ts


// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

import { Player } from "./player.ts";
import { Recorder } from "./recorder.ts";
import "./style.css";
import { LowLevelRTClient, SessionUpdateMessage, Voice } from "rt-client";

let realtimeStreaming: LowLevelRTClient;
let audioRecorder: Recorder;
let audioPlayer: Player;

async function start_realtime(endpoint: string, apiKey: string, deploymentOrModel: string) {
  if (isAzureOpenAI()) {
    realtimeStreaming = new LowLevelRTClient(new URL(endpoint), { key: apiKey }, { deployment: deploymentOrModel });
  } else {
    realtimeStreaming = new LowLevelRTClient({ key: apiKey }, { model: deploymentOrModel });
  }

  try {
    console.log("sending session config");
    await realtimeStreaming.send(createConfigMessage());
  } catch (error) {
    console.log(error);
    makeNewTextBlock("[Connection error]: Unable to send initial config message. Please check your endpoint and authentication details.");
    setFormInputState(InputState.ReadyToStart);
    return;
  }
  console.log("sent");
  await Promise.all([resetAudio(true), handleRealtimeMessages()]);
}

function createConfigMessage() : SessionUpdateMessage {

  let configMessage : SessionUpdateMessage = {
    type: "session.update",
    session: {
      turn_detection: {
        type: "server_vad",
      },
      input_audio_transcription: {
        model: "whisper-1"
      }
    }
  };

  const systemMessage = getSystemMessage();
  const temperature = getTemperature();
  const voice = getVoice();

  if (systemMessage) {
    configMessage.session.instructions = systemMessage;
  }
  if (!isNaN(temperature)) {
    configMessage.session.temperature = temperature;
  }
  if (voice) {
    configMessage.session.voice = voice;
  }

  return configMessage;
}

async function handleRealtimeMessages() {
  for await (const message of realtimeStreaming.messages()) {
    let consoleLog = "" + message.type;

    switch (message.type) {
      case "session.created":
        setFormInputState(InputState.ReadyToStop);
        makeNewTextBlock("<< Session Started >>");
        makeNewTextBlock();
        break;
      case "response.audio_transcript.delta":
        appendToTextBlock(message.delta);
        break;
      case "response.audio.delta":
        const binary = atob(message.delta);
        const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
        const pcmData = new Int16Array(bytes.buffer);
        audioPlayer.play(pcmData);
        break;

      case "input_audio_buffer.speech_started":
        makeNewTextBlock("<< Speech Started >>");
        let textElements = formReceivedTextContainer.children;
        latestInputSpeechBlock = textElements[textElements.length - 1];
        makeNewTextBlock();
        audioPlayer.clear();
        break;
      case "conversation.item.input_audio_transcription.completed":
        latestInputSpeechBlock.textContent += " User: " + message.transcript;
        break;
      case "response.done":
        formReceivedTextContainer.appendChild(document.createElement("hr"));
        break;
      default:
        consoleLog = JSON.stringify(message, null, 2);
        break
    }
    if (consoleLog) {
      console.log(consoleLog);
    }
  }
  resetAudio(false);
}

/**
 * Basic audio handling
 */

let recordingActive: boolean = false;
let buffer: Uint8Array = new Uint8Array();

function combineArray(newData: Uint8Array) {
  const newBuffer = new Uint8Array(buffer.length + newData.length);
  newBuffer.set(buffer);
  newBuffer.set(newData, buffer.length);
  buffer = newBuffer;
}

function processAudioRecordingBuffer(data: Buffer) {
  const uint8Array = new Uint8Array(data);
  combineArray(uint8Array);
  if (buffer.length >= 4800) {
    const toSend = new Uint8Array(buffer.slice(0, 4800));
    buffer = new Uint8Array(buffer.slice(4800));
    const regularArray = String.fromCharCode(...toSend);
    const base64 = btoa(regularArray);
    if (recordingActive) {
      realtimeStreaming.send({
        type: "input_audio_buffer.append",
        audio: base64,
      });
    }
  }

}

async function resetAudio(startRecording: boolean) {
  recordingActive = false;
  if (audioRecorder) {
    audioRecorder.stop();
  }
  if (audioPlayer) {
    audioPlayer.clear();
  }
  audioRecorder = new Recorder(processAudioRecordingBuffer);
  audioPlayer = new Player();
  audioPlayer.init(24000);
  if (startRecording) {
    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
    audioRecorder.start(stream);
    recordingActive = true;
  }
}

/**
 * UI and controls
 */

const formReceivedTextContainer = document.querySelector<HTMLDivElement>(
  "#received-text-container",
)!;
const formStartButton =
  document.querySelector<HTMLButtonElement>("#start-recording")!;
const formStopButton =
  document.querySelector<HTMLButtonElement>("#stop-recording")!;
const formClearAllButton =
  document.querySelector<HTMLButtonElement>("#clear-all")!;
const formEndpointField =
  document.querySelector<HTMLInputElement>("#endpoint")!;
const formAzureToggle =
  document.querySelector<HTMLInputElement>("#azure-toggle")!;
const formApiKeyField = document.querySelector<HTMLInputElement>("#api-key")!;
const formDeploymentOrModelField = document.querySelector<HTMLInputElement>("#deployment-or-model")!;
const formSessionInstructionsField =
  document.querySelector<HTMLTextAreaElement>("#session-instructions")!;
const formTemperatureField = document.querySelector<HTMLInputElement>("#temperature")!;
const formVoiceSelection = document.querySelector<HTMLInputElement>("#voice")!;

let latestInputSpeechBlock: Element;

enum InputState {
  Working,
  ReadyToStart,
  ReadyToStop,
}

function isAzureOpenAI(): boolean {
  return formAzureToggle.checked;
}

function guessIfIsAzureOpenAI() {
  const endpoint = (formEndpointField.value || "").trim();
  formAzureToggle.checked = endpoint.indexOf('azure') > -1;
}

function setFormInputState(state: InputState) {
  formEndpointField.disabled = state != InputState.ReadyToStart;
  formApiKeyField.disabled = state != InputState.ReadyToStart;
  formDeploymentOrModelField.disabled = state != InputState.ReadyToStart;
  formStartButton.disabled = state != InputState.ReadyToStart;
  formStopButton.disabled = state != InputState.ReadyToStop;
  formSessionInstructionsField.disabled = state != InputState.ReadyToStart;
  formAzureToggle.disabled = state != InputState.ReadyToStart;
}

function getSystemMessage(): string {
  return formSessionInstructionsField.value || "";
}

function getTemperature(): number {
  return parseFloat(formTemperatureField.value);
}

function getVoice(): Voice {
  return formVoiceSelection.value as Voice;
}

function makeNewTextBlock(text: string = "") {
  let newElement = document.createElement("p");
  newElement.textContent = text;
  formReceivedTextContainer.appendChild(newElement);
}

function appendToTextBlock(text: string) {
  let textElements = formReceivedTextContainer.children;
  if (textElements.length == 0) {
    makeNewTextBlock();
  }
  textElements[textElements.length - 1].textContent += text;
}

formStartButton.addEventListener("click", async () => {
  setFormInputState(InputState.Working);

  const endpoint = formEndpointField.value.trim();
  const key = formApiKeyField.value.trim();
  const deploymentOrModel = formDeploymentOrModelField.value.trim();

  if (isAzureOpenAI() && !endpoint && !deploymentOrModel) {
    alert("Endpoint and Deployment are required for Azure OpenAI");
    return;
  }

  if (!isAzureOpenAI() && !deploymentOrModel) {
    alert("Model is required for OpenAI");
    return;
  }

  if (!key) {
    alert("API Key is required");
    return;
  }

  try {
    start_realtime(endpoint, key, deploymentOrModel);
  } catch (error) {
    console.log(error);
    setFormInputState(InputState.ReadyToStart);
  }
});

formStopButton.addEventListener("click", async () => {
  setFormInputState(InputState.Working);
  resetAudio(false);
  realtimeStreaming.close();
  setFormInputState(InputState.ReadyToStart);
});

formClearAllButton.addEventListener("click", async () => {
  formReceivedTextContainer.innerHTML = "";
});

formEndpointField.addEventListener('change', async () => {
  guessIfIsAzureOpenAI();
});
guessIfIsAzureOpenAI();

Player.ts

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

export class Player {
  private playbackNode: AudioWorkletNode | null = null;

  async init(sampleRate: number) {
    const audioContext = new AudioContext({ sampleRate });
    await audioContext.audioWorklet.addModule("playback-worklet.js");

    this.playbackNode = new AudioWorkletNode(audioContext, "playback-worklet");
    this.playbackNode.connect(audioContext.destination);
  }

  play(buffer: Int16Array) {
    if (this.playbackNode) {
      this.playbackNode.port.postMessage(buffer);
    }
  }

  clear() {
    if (this.playbackNode) {
      this.playbackNode.port.postMessage(null);
    }
  }
}

recorder.ts


// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

export class Recorder {
  onDataAvailable: (buffer: Buffer) => void;
  private audioContext: AudioContext | null = null;
  private mediaStream: MediaStream | null = null;
  private mediaStreamSource: MediaStreamAudioSourceNode | null = null;
  private workletNode: AudioWorkletNode | null = null;

  public constructor(onDataAvailable: (buffer: Buffer) => void) {
    this.onDataAvailable = onDataAvailable;
  }

  async start(stream: MediaStream) {
    try {
      this.audioContext = new AudioContext({ sampleRate: 24000 });
      await this.audioContext.audioWorklet.addModule(
        "./audio-worklet-processor.js",
      );
      this.mediaStream = stream;
      this.mediaStreamSource = this.audioContext.createMediaStreamSource(
        this.mediaStream,
      );
      this.workletNode = new AudioWorkletNode(
        this.audioContext,
        "audio-worklet-processor",
      );
      this.workletNode.port.onmessage = (event) => {
        this.onDataAvailable(event.data.buffer);
      };
      this.mediaStreamSource.connect(this.workletNode);
      this.workletNode.connect(this.audioContext.destination);
    } catch (error) {
      this.stop();
    }
  }

  stop() {
    if (this.mediaStream) {
      this.mediaStream.getTracks().forEach((track) => track.stop());
    }
    if (this.audioContext) {
      this.audioContext.close();
    }
  }
}

index.html

<!--
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
-->

<!doctype html>
<html lang="en">

<head>
  <meta charset="UTF-8" />
  <link rel="icon" type="image/svg+xml" href="/vite.svg" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Realtime API with openai-node SDK</title>
</head>

<body>
  <div id="app">
    <form>
      <div class="container">
        <div id="received-text-container"></div>
        <div class="controls">
          <div class="input-group">
            <label for="endpoint">Endpoint</label>
            <input id="endpoint" type="text" placeholder="Enter resource/endpoint URL" />
            <div class="toggle-group">
              <label for="azure-toggle">Azure OpenAI</label>
              <input id="azure-toggle" type="checkbox" checked />
            </div>
              <label for="api-key">API Key</label>
            <input id="api-key" type="password" placeholder="Enter API key" />
            <label for="deployment-or-model">Deployment</label>
            <input id="deployment-or-model" type="text" placeholder="Enter deployment/model, e.g. gpt-4o-realtime-preview-2024-10-01" />
          </div>
          <div class="input-group">
          <div class="button-group">
            <button id="start-recording" type="button">Record</button>
            <button id="stop-recording" type="button" disabled="true">Stop</button>
          </div>
          <div class="input-group">
            <label for="session-instructions">System Message</label>
            <textarea id="session-instructions" placeholder="Optional instructions for the session, e.g. 'You talk like a pirate.'" rows="4"></textarea>
          </div>
          <div class="input-group">
            <label for="temperature">Temperature</label>
            <input id="temperature" type="number" min="0.6" max="1.2" step="0.05" placeholder="0.6-1.2 (default 0.8)"/>
          </div>
          <div class="input-group">
            <label for="voice">Voice</label>
              <select id="voice">
                <option></option>
                <option>alloy</option>
                <option>ash</option>
                <option>ballad</option>
                <option>coral</option>
                <option>echo</option>
                <option>sage</option>
                <option>shimmer</option>
                <option>verse</option>
              </select>
          </div>
          <div class="button-group">
            <button id="clear-all" type="button">Clear all</button>
          </div>
        </div>
      </div>
    </form>
  </div>
  <script type="module" src="/src/main.ts"></script>
</body>

</html>

Why React Native and Expo?

React Native allows developers to build mobile apps using JavaScript and React. Expo takes it a step further by providing a suite of tools and services that streamline the development process, including the ability to run your app on web platforms.

Step 1: Setting Up Your Environment

Before diving into the code, ensure you have the following installed:

• Node.js
• Expo CLI (npm install -g expo-cli)
• Git (optional, for version control)

Step 2: Enabling Web Support

To get started, navigate to your React Native project directory and run the following command to install the necessary dependencies for web support:

npx expo install react-native-web@~0.18.0 react-dom@18.2.0 @expo/webpack-config@^0.17.0

Step 3: Configuring Webpack

Create a webpack.config.js file in the root of your project with the following content:

const { withExpo } = require('@expo/webpack-config');
module.exports = async function (env, argv) {
  return withExpo(env, argv);
};

This configuration leverages Expo’s built-in Webpack settings to bundle your app for the web.

Step 4: Running Your App on Web

To see your app in action on the web, run:

npx expo start --web

This command will launch a local web server, allowing you to interact with your app in a web browser.

Step 5: Adjusting Styles and Components

Web and mobile have different style requirements. Ensure your app looks great on both platforms by using the Platform module from React Native to conditionally apply styles:

javascript

import { Platform, StyleSheet } from 'react-native';

const styles = StyleSheet.create({
  container: {
    ...Platform.select({
      web: {
        // Web-specific styles
      },
      default: {
        // Mobile-specific styles
      },
    }),
  },
});

Step 6: Building for Production

Once your app is polished and ready, create a production build by running:

npx expo build:web

This command generates a web-build directory containing your web app’s static files.

Step 7: Deploying Your Web App

There are various hosting services you can use to deploy your web app. Here are a few options:

• Vercel:

1. Sign up at Vercel.
2. Import your project repository.
3. Vercel will automatically detect the web-build directory and deploy your app.

• Netlify:

1. Sign up at Netlify.
2. Connect your project repository.
3. Set the build command to npx expo build:web and the publish directory to web-build.

• GitHub Pages:

1. Push your project to a GitHub repository.
2. Enable GitHub Pages in the repository settings.
3. Use gh-pages to publish your web-build directory

npm install gh-pages --save-dev

1. Add the following scripts to your package.json:

"scripts": {   "predeploy": "expo build:web",   "deploy": "gh-pages -d web-build" }

Run:

npm run deploy

Conclusion

By following these steps, you can extend your React Native app’s reach to the web, providing a consistent and engaging experience for your users. The process may seem complex at first, but with Expo and a bit of tweaking, your app can thrive on any platform.

Happy coding!

foIIow me here

Caleb Jephunneh | WhatsApp Channel

https://whatsapp.com/channel/0029VapMNlKAInPt93qoA826

Here’s how WinHackathons empowers you:

✅ Generate Winning AI Ideas 🤖

Struggling to come up with a groundbreaking solution?
Our AI-powered idea generation tools help you brainstorm unique, impactful concepts designed to wow hackathon judges and solve real-world problems.

✅ Build AI-Driven Pitch Decks 📊

You’ve got the idea; now it’s time to sell it.
WinHackathons ensures your story stands out with automated, polished pitch decks tailored to showcase your solution and impress your audience.

✅ Collaborate Seamlessly 🤝

Hackathons are all about teamwork, but finding the right teammates can be a challenge.
With WinHackathons, you can connect with like-minded innovators, build your dream team, and work on projects that truly make a difference.

🌍 A Platform for Everyone

Whether you’re a coder, designer, or problem-solver, WinHackathons equips you with the tools to shine. From ideation to execution, we’ve got you covered.

Hackathons = Innovation + Collaboration. WinHackathons = Your Success Formula.

👉 Visit winhackathons.com now and take the first step toward your next big victory!

Let’s innovate, collaborate, and win together. 💡🏆

#Hackathons #AIInnovation #TechCollaboration #WinHackathons #PitchPerfect

When people see my LinkedIn profile, they see 39× hackathon wins and think “Wow, that’s a lot of code!” What they don’t see is that my secret weapon isn’t my technical skills — it’s my ability to craft a compelling narrative. Here’s why storytelling trumps coding in hackathons:

🎨 THE ART OF THE PITCH
In hackathons, you’re not just building a project — you’re selling an idea, a dream, an 𝘦𝘷𝘦𝘳𝘥𝘪𝘴𝘵𝘢𝘯𝘵 𝘶𝘵𝘰𝘱𝘪𝘢, if you will. I once won a hackathon with a UI that was mostly smoke and mirrors. 𝗧𝗵𝗲 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝘄𝗮𝘀 𝗵𝗲𝗹𝗱 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿 𝘄𝗶𝘁𝗵 𝗱𝘂𝗰𝘁 𝘁𝗮𝗽𝗲 𝗮𝗻𝗱 𝗵𝗼𝗽𝗲, 𝗯𝘂𝘁 𝗼𝘂𝗿 𝘀𝘁𝗼𝗿𝘆 𝗼𝗳 𝗵𝗼𝘄 𝗶𝘁 𝗰𝗼𝘂𝗹𝗱 𝗰𝗵𝗮𝗻𝗴𝗲 𝘁𝗵𝗲 𝘄𝗼𝗿𝗹𝗱 𝘄𝗮𝘀 𝗶𝗿𝗿𝗲𝘀𝗶𝘀𝘁𝗶𝗯𝗹𝗲.

💡 TAILORED NARRATIVES
Judges aren’t just evaluating code — they’re buying into visions. I’ve learned to tailor my pitch to each judge’s background. 𝗔𝘁 𝗮 𝗿𝗲𝗰𝗲𝗻𝘁 𝗵𝗮𝗰𝗸𝗮𝘁𝗵𝗼𝗻, 𝗜 𝗽𝗶𝘁𝗰𝗵𝗲𝗱 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝘁𝗵𝗿𝗲𝗲 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘄𝗮𝘆𝘀 𝘁𝗼 𝘁𝗵𝗿𝗲𝗲 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗷𝘂𝗱𝗴𝗲𝘀. 𝗪𝗲 𝘄𝗼𝗻 𝗳𝗶𝗿𝘀𝘁 𝗽𝗹𝗮𝗰𝗲.

🚀 BEYOND THE HACKATHON
This skill isn’t just for winning prizes — it’s liquid gode for careers. The ability to tell a compelling story about your work is invaluable in:

1. Startup pitches
2. Product management
3. Technical interviews: 𝗜 𝗹𝗮𝗻𝗱𝗲𝗱 a 𝗷𝗼𝗯 𝗯𝘆 𝘁𝗲𝗹𝗹𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝘁𝗼𝗿𝘆 𝗼𝗳 𝗮 𝗵𝗮𝗰𝗸𝗮𝘁𝗵𝗼𝗻 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝘁𝗵𝗮𝘁 𝗱𝗶𝗱𝗻’𝘁 𝗲𝘃𝗲𝗻 𝘄𝗶𝗻 𝗮𝗻𝘆𝘁𝗵𝗶𝗻𝗴!

💼 THE ETHICS OF STORYTELLING
Now, you might be thinking, “Isn’t this just smoke and mirrors?” Here’s the truth: A hackathon isn’t about showcasing a finished product — it’s about pitching potential. 𝗬𝗼𝘂’𝗿𝗲 𝗻𝗼𝘁 𝘀𝗲𝗹𝗹𝗶𝗻𝗴 𝘄𝗵𝗮𝘁 𝘆𝗼𝘂’𝘃𝗲 𝗯𝘂𝗶𝗹𝘁 𝗶𝗻 𝟮𝟰 𝗵𝗼𝘂𝗿𝘀 — 𝘆𝗼𝘂’𝗿𝗲 𝘀𝗲𝗹𝗹𝗶𝗻𝗴 𝘁𝗵𝗲 𝗱𝗿𝗲𝗮𝗺 𝗼𝗳 𝘄𝗵𝗮𝘁 𝗶𝘁 𝗰𝗼𝘂𝗹𝗱 𝗯𝗲𝗰𝗼𝗺𝗲.

🌟 MY HACKATHON TIPS:

1. Focus on the problem you’re solving, not just your solution.
2. Practice your pitch as much as you code.
3. Use analogies to make complex tech relatable.
4. Show passion — enthusiasm is contagious!
5. Be ready to pivot your story based on judges’ reactions.

Remember, in hackathons and in life, it’s not just about what you build — it’s about the story you tell. Master this, and you’ll not only win hackathons but also hearts, minds, and maybe even your dream job.

For more of this content follow my WhatsApp channel 👉https://whatsapp.com/channel/0029VapMNlKAInPt93qoA826

Well, let me correct that—𝗜 𝗱𝗼𝗻’𝘁 𝘄𝗿𝗶𝘁𝗲 𝙖𝙡𝙡 𝗺𝘆 𝗰𝗼𝗱𝗲 𝗮𝘁 𝗵𝗮𝗰𝗸𝗮𝘁𝗵𝗼𝗻𝘀.

Something I learned from Hackcon by Major League Hacking is that software engineers are transitioning from 𝘤𝘳𝘦𝘢𝘵𝘪𝘯𝘨 code to 𝘦𝘥𝘪𝘵𝘪𝘯𝘨 it. I realized I’ve been subconsciously doing this already.

At most hackathons, I rely on AI-based tools to generate boilerplate code. From there, I modify and optimize it to fit my project. Here are the three AI tools that have massively boosted my workflow at hackathons:

🔥 𝗖𝘂𝗿𝘀𝗼𝗿 𝗖𝗼𝗱𝗲 𝗘𝗱𝗶𝘁𝗼𝗿
A fork of Visual Studio Code that uses your entire codebase as a knowledge base. It’s brilliant for context-aware code generation, far better than GitHub Copilot. Cursor even allows inline edits—𝗲𝗱𝗶𝘁𝗶𝗻𝗴 your code rather than generating it from scratch.

🚀 𝗩𝗲𝗿𝗰𝗲𝗹 𝗩𝟬
V0 is a generative user interface system by Vercel that outputs React code powered by 𝘀𝗵𝗮𝗱𝗰𝗻/𝘂𝗶 and 𝗧𝗮𝗶𝗹𝘄𝗶𝗻𝗱 𝗖𝗦𝗦. For me, this is a no-brainer because I’m already using Next.js. It can even generate custom components you can 𝗻𝗽𝗺 𝗶𝗻𝘀𝘁𝗮𝗹𝗹 directly into your project—𝘪𝘯𝘴𝘵𝘢𝘯𝘵 𝘱𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘷𝘪𝘵𝘺 𝘣𝘰𝘰𝘴𝘵.

🤖 𝗖𝗹𝗮𝘂𝗱𝗲 𝗔𝗿𝘁𝗶𝗳𝗮𝗰𝘁𝘀
Part of 𝗖𝗹𝗮𝘂𝗱𝗲 𝟯.𝟱, this feature simplifies code generation in a traditional chat interface. You can view live previews and access a history of your interactions, all in an easy-to-navigate tab. It’s a game changer for debugging and understanding your teammates’ code in the middle of a hackathon. This tool has saved me 𝘵𝘦𝘯𝘴 𝘰𝘧 𝘩𝘰𝘶𝘳𝘴 𝘢𝘵 𝘦𝘢𝘤𝘩 𝘩𝘢𝘤𝘬𝘢𝘵𝘩𝘰𝘯.

Here’s the big shift: The primary role of a software engineer is evolving from 𝘤𝘰𝘥𝘦 𝘤𝘳𝘦𝘢𝘵𝘪𝘰𝘯 to 𝘤𝘰𝘥𝘦 𝘤𝘶𝘳𝘢𝘵𝘪𝘰𝘯. We’re no longer just writing code—we’re guiding AI tools to build it smarter and faster.