We now live in a different world.

Acceleration is imminent.

You *will* need to adjust your worldview.

This is what the early days of the singularity look like.

And you are living through them.


There is absolute no situation in which you will outcompete someone who is using o3 and you are not.

This clearly seems like the model that will begin to actually spark a real AGI debate.

Based on the numbers they’re showing today?

Not sure I’d argue against it.

I asked o1 pro to implement 6 things I had on my todo list for a project today.

- It thought for 5m 25s.
- Modified 14 files.
- 64,852 input tokens.
- 14,740 output tokens.

Got it 100% correct - saved me 2 hours.

Absolute powerhouse.


Including my o1 workflow video + GitHub link to my xml parser for the ai code cowboys out there who want to come explore the wild west.

It’s nice over here.

GitHub: github.com/mckaywrigley/o…

Workflow Video: x.com/mckaywrigley/s…

Here’s how to use OpenAI’s new o1 pro model to maximize coding productivity.

I’ve used this workflow for the last 48hrs and I estimate it has 2x’d my output.

Watch the full 19min tutorial.

Prompt below. Actual workflow demo at start.

17:00ish for tool stack.

Here’s the full o1 XML prompt:

—

You are an expert software engineer.

You are tasked with following my instructions.

Use the included project instructions as a general guide.

You will respond with 2 sections: A summary section and an XLM section.

Here are some notes on how you should respond in the summary section:

- Provide a brief overall summary
- Provide a 1-sentence summary for each file changed and why.
- Provide a 1-sentence summary for each file deleted and why.
- Format this section as markdown.

Here are some notes on how you should respond in the XML section:

- Respond with the XML and nothing else
- Include all of the changed files
- Specify each file operation with CREATE, UPDATE, or DELETE
- If it is a CREATE or UPDATE include the full file code. Do not get lazy.
- Each file should include a brief change summary.
- Include the full file path
- I am going to copy/paste that entire XML section into a parser to automatically apply the changes you made, so put the XML block inside a markdown codeblock.
- Make sure to enclose the code with ![CDATA[__CODE HERE__]]

Here is how you should structure the XML:




**BRIEF CHANGE SUMMARY HERE**
**FILE OPERATION HERE**
**FILE PATH HERE**
__FULL FILE CODE HERE__
]]>

**REMAINING FILES HERE**



So the XML section will be:

```xml
__XML HERE__
```
[[PUT CURSOR RULES HERE]]

[[PUT YOUR INSTRUCTIONS HERE]]

ChatGPT’s Advanced Voice mode is the most magical product I’ve ever used.

Total game changer.

And imagine when OpenAI makes it available via API…

Add basic retrieval + function calling to voice and you’ll have an on-demand virtual assistant for anything.

The future is here. I basically had this moment with Advanced Voice yesterday.

It’s literal magic.

(OpenAI let me pay you for more use!!)

https://twitter.com/davidsholz/status/1833588201472344388

My #1 takeaway so far after using OpenAI’s new o1 model…

We’re about to have the ChatGPT moment for agentic coding systems.

o1’s ability to think, plan, and execute is off the charts.

The wave of products that will be built with this will be unlike anything we’ve ever seen. Expect the Cursor Composers, Replit Agents, Devins, etc of the world to take a massive leap.

Will take a little bit of time bc standard prompting techniques aren’t that effective so we need to learn the system.

But expect many more tools like the above for various professions.

In Cursor I’m able to generate a fully functional backend with a single prompt.

A working database in <2min.

Composer is pure magic.

Full prompt below. PUT THIS PROMPT IN A `` FILE:

--

# Backend Setup Instructions

Use this guide to setup the backend for this project.

It uses Supabase, Drizzle ORM, and Server Actions.

Write the complete code for every step. Do not get lazy. Write everything that is needed.

Your goal is to completely finish the backend setup.

## Helpful Links

If the user gets stuck, refer them to the following links:

- [Supabase Docs]()
- [Drizzle Docs]()
- [Drizzle with Supabase Quickstart]()

## Install Libraries

Make sure the user knows to install the following libraries:

```bash
npm i drizzle-orm dotenv postgres
npm i -D drizzle-kit
```

## Setup Steps

- [ ] Create a `/db` folder in the root of the project

- [ ] Create a `/types` folder in the root of the project

- [ ] Add a `drizzle.config.ts` file to the root of the project with the following code:

```ts
import { config } from "dotenv";
import { defineConfig } from "drizzle-kit";

config({ path: ".env.local" });

export default defineConfig({
schema: "./db/schema/index.ts",
out: "./db/migrations",
dialect: "postgresql",
dbCredentials: {
url: process.env.DATABASE_URL!
}
});
```

- [ ] Add a file called `db.ts` to the `/db` folder with the following code:

```ts
import { config } from "dotenv";
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import { exampleTable } from "./schema";

config({ path: ".env.local" });

const schema = {
exampleTable
};

const client = postgres(process.env.DATABASE_URL!);

export const db = drizzle(client, { schema });
```

- [ ] Create 2 folders in the `/db` folder:

- `/schema`
- Add a file called `index.ts` to the `/schema` folder
- `/queries`

- [ ] Create an example table in the `/schema` folder called `example-schema.ts` with the following code:

```ts
import { integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";

export const exampleTable = pgTable("example", {
id: uuid("id").defaultRandom().primaryKey(),
name: text("name").notNull(),
age: integer("age").notNull(),
email: text("email").notNull(),
createdAt: timestamp("created_at").defaultNow().notNull(),
updatedAt: timestamp("updated_at")
.notNull()
.defaultNow()
.$onUpdate(() => new Date())
});

export type InsertExample = typeof exampleTable.$inferInsert;
export type SelectExample = typeof exampleTable.$inferSelect;
```

- [ ] Export the example table in the `/schema/index.ts` file like so:

```ts
export * from "./example-schema";
```

- [ ] Create a new file called `example-queries.ts` in the `/queries` folder with the following code:

```ts
"use server";

import { eq } from "drizzle-orm";
import { db } from "../db";
import { InsertExample, SelectExample } from "../schema/example-schema";
import { exampleTable } from "./../schema/example-schema";

export const createExample = async (data: InsertExample) => {
try {
const [newExample] = await db.insert(exampleTable).values(data).returning();
return newExample;
} catch (error) {
console.error("Error creating example:", error);
throw new Error("Failed to create example");
}
};

export const getExampleById = async (id: string) => {
try {
const example = await db.query.exampleTable.findFirst({
where: eq(, id)
});
if (!example) {
throw new Error("Example not found");
}
return example;
} catch (error) {
console.error("Error getting example by ID:", error);
throw new Error("Failed to get example");
}
};

export const getAllExamples = async (): Promise => {
return db.query.exampleTable.findMany();
};

export const updateExample = async (id: string, data: Partial) => {
try {
const [updatedExample] = await db.update(exampleTable).set(data).where(eq(, id)).returning();
return updatedExample;
} catch (error) {
console.error("Error updating example:", error);
throw new Error("Failed to update example");
}
};

export const deleteExample = async (id: string) => {
try {
await db.delete(exampleTable).where(eq(, id));
} catch (error) {
console.error("Error deleting example:", error);
throw new Error("Failed to delete example");
}
};
```

- [ ] In `package.json`, add the following scripts:

```json
"scripts": {
"db:generate": "npx drizzle-kit generate",
"db:migrate": "npx drizzle-kit migrate"
}
```

- [ ] Run the following command to generate the tables:

```bash
npm run db:generate
```

- [ ] Run the following command to migrate the tables:

```bash
npm run db:migrate
```

- [ ] Create a folder called `/actions` in the root of the project for server actions

- [ ] Create folder called `/types` in the root of the project for shared types

- [ ] Create a file called `action-types.ts` in the `/types/actions` folder for server action types with the following code:

- [ ] Create file called `/types/index.ts` and export all the types from the `/types` folder like so:

```ts
export * from "./action-types";
```

- [ ] Create a file called `example-actions.ts` in the `/actions` folder for the example table's actions:

```ts
"use server";

import { createExample, deleteExample, getAllExamples, getExampleById, updateExample } from "@/db/queries/example-queries";
import { InsertExample } from "@/db/schema/example-schema";
import { ActionState } from "@/types";
import { revalidatePath } from "next/cache";

export async function createExampleAction(data: InsertExample): Promise {
try {
const newExample = await createExample(data);
revalidatePath("/examples");
return { status: "success", message: "Example created successfully", data: newExample };
} catch (error) {
return { status: "error", message: "Failed to create example" };
}
}

export async function getExampleByIdAction(id: string): Promise {
try {
const example = await getExampleById(id);
return { status: "success", message: "Example retrieved successfully", data: example };
} catch (error) {
return { status: "error", message: "Failed to get example" };
}
}

export async function getAllExamplesAction(): Promise {
try {
const examples = await getAllExamples();
return { status: "success", message: "Examples retrieved successfully", data: examples };
} catch (error) {
return { status: "error", message: "Failed to get examples" };
}
}

export async function updateExampleAction(id: string, data: Partial): Promise {
try {
const updatedExample = await updateExample(id, data);
revalidatePath("/examples");
return { status: "success", message: "Example updated successfully", data: updatedExample };
} catch (error) {
return { status: "error", message: "Failed to update example" };
}
}

export async function deleteExampleAction(id: string): Promise {
try {
await deleteExample(id);
revalidatePath("/examples");
return { status: "success", message: "Example deleted successfully" };
} catch (error) {
return { status: "error", message: "Failed to delete example" };
}
}
```

```ts
export type ActionState = {
status: "success" | "error";
message: string;
data?: any;
};
```
- [ ] Implement the server actions in the `/app/page.tsx` file to allow for manual testing.

- [ ] The backend is now setup.setup-backend.md

We’re at the point with AI codegen where Cursor + Claude 3.5 Sonnet is a legit technical cofounder. The ceiling on complexity that it can handle will continue to go up over time, and this will happen quite quickly.

We are still early, and it’s already this good.

Learn how to communicate clearly and manage context effectively.

Do not let others tell you what you can’t build.

Here’s a 17min deep dive on advanced prompting techniques for LLMs.

Fully demonstrated on a real-world, multi-step AI workflow.

Watch for a complete breakdown. The video covers:

- prompt chaining
- chain-of-thought with <scratchpad> tags
- xml tags
- system vs. user messages
- output parsing
- prefilling
- information hierarchy
- role prompting
- goal prompting
- recursive llm calls

Lots of good stuff in there!

I’m blown away by Devin.

Watch me use it for 27min.

It’s insane.

The era of AI agents has begun. Devin feels like the ChatGPT moment for AI agents.

Exceptional work from the Cognition team.

It’s going to be fun to experiment and figure out where it’s most useful in its current state.

This is the worst it’ll ever be - the future is bright!

ChatGPT just killed Siri.

You can now:
- use ChatGPT with Siri
- start new chats
- continue old chats
- sync chats to ChatGPT app

I built “Let’s Chat” so everyone can take advantage of this and have a more powerful AI voice assistant!

Install: icloud.com/shortcuts/8c4c… How to adjust starting prompt and switch to using GPT-4.

LangChain 101: Models is live!

Come learn the basics of using models in @LangChainAI - great for beginners!

This is part 1 of @TakeoffAI’s 100% free 6 part LangChain 101 course.

Click the link to start the lesson as a project in @Replit.

Take Course: replit.com/@MckayWrigley/… The 101 track will be relatively basic.

I’m a strong believer in both understanding fundamentals and in helping onboard beginners!

But I plan on doing 201, 301, and 401 next to build a series of stepping stones to become a pro AI developer.

Part 2 (prompts) drops tomorrow.

Can you imagine if Drake made his own AI music app where anyone could use his voice to create new songs?

It would become the #1 app overnight.

Millions of paying users in hours.

It’s all anyone would post about.

There are *wildly* interesting opportunities for artists in AI. Grimes gets it.

https://twitter.com/grimezsz/status/1650304051718791170

AI is bringing in a *massive* new wave of people who are learning to code.

Why?

They want to run & build AI programs!

One of the interesting developments around this is that GitHub is becoming a sort of AI App Store.

And git clone is now the download button for AI apps. I’ve seen a lot of pathetic gatekeepy behavior from programmer vets towards our new friends.

“Oh noooo auto-gpt has more stars than PyTorch now what are we gonna dooooo.”

How about encourage them?

More people are discovering the magical world of software - welcome them! :)

AI music is here.

This is the 1st example of AI generated music that *really* wowed me.

This guy ghostwriter977 on TikTok made a Drake x The Weeknd track that’s actually kind of insane?

You’ll soon be able to make unlimited music by your favorite artists on demand with AI. If you told me this was a leak from an old mixtape I would’ve 100% believed you.

Imagine where this is in a year…

Obviously there are a ton of major copyright questions and whatnot, but you can’t deny that this is going to became a huge thing *really* quickly.

Introducing AI Brainstore!

It’s a proof-of-concept of a brain for an AI agent.

Ask an agent a question, it checks its memories for an answer, otherwise it browses the web and learns the answer.

As it learns, it saves memories to its brain.

GitHub: github.com/mckaywrigley/a… I *really* encourage people to go wild with experimenting here.

You can do some pretty outrageous things.

As mentioned in the clip, I’m going to try and show a more advanced example this week.

I’m just very swamped, but I wanted to at least get a basic template out :)

Well that escalated quickly. i got exposed smh

GPT-4 has its own compression language.

I generated a 70 line React component that was 794 tokens.

It compressed it down to this 368 token snippet, and then it deciphered it with 100% accuracy in a *new* chat with zero context.

This is crazy! This example is pretty simple - strips away stuff like vowels, etc.

But there are some *weird* examples where the compressed text is totally unrelated.

Currently using @gfodor’s prompt, but there are others out there.

PROMPT
—
Compressor: compress the following text in a way… twitter.com/i/web/status/1…

Jarvis is now reality.

My GPT-4 coding assistant can now build & deploy brand new web apps!

It initializes my project, builds my app, creates a GitHub repo, and deploys it to Vercel.

All from simply using my voice. Built with @CodewandAI.

Our 1st tool (of many coming!) comes out soon.

It’s not this one, but this feature is on the way.

Excited to start sharing these next-gen AI devtools with you.

What if writing code was as simple as talking to your device?

Watch my GPT-4 voice assistant:
- take in a complex coding task
- write the code
- create a PR on my GitHub repo

All I had to do was tell it what to do.

This is the future of software. Powered by @CodewandAI.

(and yes I can use it on my phone too but I need my phone to film haha)

The issues with Chatbot UI & OpenAI have been resolved.

Huge thanks to their team for the quick response and the clarity on what happened.

OpenAI was *exceptionally* helpful here, and it’s very important to me that you all know that.

Now… back to building! And I apologize for taking down the site without warning.

Didn’t have any interest in legal issues so I complied immediately.

I’ll always do anything I can to keep it up for you if you can’t run locally!

I pay a decent amount out of pocket to keep it up bc I believe in it.

I have been informed that I need to take down the hosted version of Chatbot UI immediately.

If anyone at OpenAI could clarify the issue I would appreciate it.

Is it the name? Is it the UI?

I love OpenAI, and I just want to build a good open source UI with tools for users. I’m really hoping it’s just a naming conflict that they want resolved, and if so I get it and am happy to change it.

I truly think the world of OpenAI - everyone there has been very kind and helpful to me and I admire them greatly as an organization.

Let’s get this resolved :)