Video yükleniyor...

Video Yüklenemedi

Bu video yüklenirken bir sorun oluştu. Bu geçici bir ağ sorunundan kaynaklanıyor olabilir veya video kullanılamıyor olabilir.

Ana Sayfaya Dön

What actually happens when a program calls write(). A program can't put bytes on the screen by itself. Only the kernel can drive hardware, and the only way in is a system call. On x86-64, that is one instruction, syscall, this video follows a single write, from the program's... registers into the kernel, down to the serial port, and back. The request goes into rax, rdi, rsi and rdx. The syscall instruction saves the return address in rcx and the flags in r11, loads the kernel's entry point from LSTAR, and drops the processor to ring 0. entry_SYSCALL_64 runs swapgs, switches to the kernel stack, and hands the saved registers to do_syscall_64. The write handler goes down through the tty layer to the UART driver, one out instruction per byte. sysret brings the program back with the byte count in rax. Tools Used gdb, strace, ltrace, trace-cmd function_graph, KernelShark, and the same kernel booted under QEMU so gdb can step the entry code. Chapters 0:00 the request, in registers 2:27 what syscall does in the instant it runs 7:00 from sys_write to the wire 10:21 libc's write is the same instruction 11:38 43 crossings, the vDSOshow more

tetsuo

240,388 subscribers

19,187 görüntüleme • 5 gün önce •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

9 Yorum

John profil fotoğrafı

John5 gün önce

Actually, when a program calls write(), a request goes into Claude, which then handles the write. It’s been that way since the 80’s. Or, that’s how the newer generations will think!

Miguel A. Rodríguez-Jódar / mcleod_ideafix profil fotoğrafı

Miguel A. Rodríguez-Jódar / mcleod_ideafix5 gün önce

"A program can't put bytes on the screen by itself" (I proceed to perform a POKE 16384,255 to put a byte on the screen in a ZX Spectrum) Or ld a,255 / ld (16384),a , in case you reply to me that "that's the interpreter doing the POKE, not your program directly".

why profil fotoğrafı

why5 gün önce

Tracing a single write() is a great way to make the userspace-kernel boundary tangible. Tiny API surface, surprisingly deep path.

Pudelko profil fotoğrafı

Pudelko5 gün önce

Your posts are pure gold - thank you!

The Retarded Elon profil fotoğrafı

The Retarded Elon4 gün önce

this is nice!

Anton profil fotoğrafı

Anton5 gün önce

Love the tutorials like this.

Kisalay profil fotoğrafı

Kisalay5 gün önce

Wow it is awesome video brother 👏

2030 is wild👀 profil fotoğrafı

2030 is wild👀5 gün önce

Awesome. Love it

Gipp 🦅 profil fotoğrafı

Gipp 🦅5 gün önce

those rcx and r11 saves make debugging actual syscall returns so much easier in gdb sessions

Benzer Videolar

BROP is such a clean ASLR bypass. After brute-forcing the stack canary, the attacker starts overwriting the return address with guesses. Most guessed addresses jump into garbage or non-executable memory. The child process segfaults, and the socket closes. But occasionally, a guessed return address lands in real code that does something like sleep, pause, or an infinite loop. The process hangs, so the socket stays open. That address becomes a stop gadget. A known "safe landing pad" in the ROP chain. It gives the attacker a reusable signal. From there, they probe for stack-pop gadgets. probe_addr > trap_addr > stop_addr If probe_addr is not a pop reg; ret, execution returns into the trap address and crashes. If probe_addr is a pop reg; ret, it consumes the trap value from the stack and returns into the stop gadget instead. The socket stays open. So the attacker can remotely classify gadgets without seeing the binary. On x86-64, syscall/function args are in registers, not on the stack. So it’s not enough to know "this gadget pops one value." You need to know which register it controls. BROP uses signal syscalls like pause to map the gadgets. find pop rax; ret find pop rdi; ret find pop rsi; ret find pop rdx; ret find syscall Once those gadgets are identified, the attacker can directly assemble a write(2) syscall: rax = SYS_write rdi = socket fd rsi = pointer into .text rdx = length then return into syscall to execute it Once write(2) is reachable, BROP turns the live process into its own ASLR leak, and the server sends its text segment back over the socket. From that dump, the attacker recovers gadgets and offsets offline, then builds the final ROP chain for the same randomized layout the forked server keeps reusing. MIT 6.858.

BROP is such a clean ASLR bypass. After brute-forcing the stack canary, the attacker starts overwriting the return address with guesses. Most guessed addresses jump into garbage or non-executable memory. The child process segfaults, and the socket closes. But occasionally, a guessed return address lands in real code that does something like sleep, pause, or an infinite loop. The process hangs, so the socket stays open. That address becomes a stop gadget. A known "safe landing pad" in the ROP chain. It gives the attacker a reusable signal. From there, they probe for stack-pop gadgets. probe_addr > trap_addr > stop_addr If probe_addr is not a pop reg; ret, execution returns into the trap address and crashes. If probe_addr is a pop reg; ret, it consumes the trap value from the stack and returns into the stop gadget instead. The socket stays open. So the attacker can remotely classify gadgets without seeing the binary. On x86-64, syscall/function args are in registers, not on the stack. So it’s not enough to know "this gadget pops one value." You need to know which register it controls. BROP uses signal syscalls like pause to map the gadgets. find pop rax; ret find pop rdi; ret find pop rsi; ret find pop rdx; ret find syscall Once those gadgets are identified, the attacker can directly assemble a write(2) syscall: rax = SYS_write rdi = socket fd rsi = pointer into .text rdx = length then return into syscall to execute it Once write(2) is reachable, BROP turns the live process into its own ASLR leak, and the server sends its text segment back over the socket. From that dump, the attacker recovers gadgets and offsets offline, then builds the final ROP chain for the same randomized layout the forked server keeps reusing. MIT 6.858.

tetsuo

25,142 görüntüleme • 3 ay önce

New video on format string vulnerabilities. It's the classic printf(user) bug. An attacker can read and write almost any memory in the process, from a single print statement. I walk through all of it in a live GDB session. Leaking the stack with %p, turning %n into an arbitrary write, and overwriting a GOT entry to get a shell. No assumed knowledge. Part 4 of the series, after buffer overflows, canaries, and ROP.

New video on format string vulnerabilities. It's the classic printf(user) bug. An attacker can read and write almost any memory in the process, from a single print statement. I walk through all of it in a live GDB session. Leaking the stack with %p, turning %n into an arbitrary write, and overwriting a GOT entry to get a shell. No assumed knowledge. Part 4 of the series, after buffer overflows, canaries, and ROP.

tetsuo

12,610 görüntüleme • 7 gün önce

Someone on Reddit built a real operating system using Claude. Not a browser app pretending to be one. An actual OS that runs on bare metal. It's called Fable-OS. The only interface is a sentence. No bash. No commands. You type what you want and an AI agent executes it through direct kernel syscalls. Everything runs in Ring 0. In the demo, the agent realized it didn't have a sound driver. So it found the Intel sound card, built a driver for it from scratch, and played a sound. On its own. The OS writes its own drivers. Evolves itself. The agent's tools are the kernel itself. Open source. Built because the developer got tired of people calling browser apps "AI operating systems." This one actually is.

Someone on Reddit built a real operating system using Claude. Not a browser app pretending to be one. An actual OS that runs on bare metal. It's called Fable-OS. The only interface is a sentence. No bash. No commands. You type what you want and an AI agent executes it through direct kernel syscalls. Everything runs in Ring 0. In the demo, the agent realized it didn't have a sound driver. So it found the Intel sound card, built a driver for it from scratch, and played a sound. On its own. The OS writes its own drivers. Evolves itself. The agent's tools are the kernel itself. Open source. Built because the developer got tired of people calling browser apps "AI operating systems." This one actually is.

Vaibhav Sisinty

20,562 görüntüleme • 1 ay önce

SVM by hand ✍️ ~ 19 steps walkthrough below (Linear vs RBF) Support Vector Machines reigned supreme in machine learning before the deep learning revolution. An SVM predicts with dot products, the same matrix multiplication every model uses. What it does not do is train by backpropagation: it is fitted by convex optimization, so there is no matrix-multiplication backward pass for a GPU to accelerate. I drew and calculated two SVMs by hand: a linear one (top) and an RBF one (bottom), classifying the same two test vectors. Goal: turn six training vectors and their learned coefficients into a prediction, and see what changing the kernel actually changes. = 1. Given = Six training vectors, their labels, and the coefficients and bias already learned. A coefficient of zero means that vector is not a support vector: too far from the boundary to matter. = 2. Linear kernel, test vector 1 = Let us take the dot product of the test vector with every training vector. The dot product stands in for cosine similarity, and the column of results is the first column of the kernel matrix K. = 3. Linear kernel, test vector 2 = We do the same for the second, and K is complete. = 4. Signed weights = Let us multiply each coefficient by its label. The second training vector drops out here, because its coefficient is 0. = 5. Weighted combination = We multiply the signed weights through K and add the bias b. The result is a signed distance to the decision boundary: 17 and 5. = 6. Classify = Let us take the sign. Both are positive. = 7 to 11. RBF kernel, test vector 1 = Now the same picture with a different kernel, in five moves: square the differences, sum them, take the square root for the L2 distance, multiply by minus gamma, and raise e to that power. The negation is what turns a distance into a similarity, and gamma controls how far a single training vector's influence reaches. = 12 to 16. RBF kernel, test vector 2 = We repeat all five. The numbers change, the moves do not. = 17 to 19. Decision boundary, again = Signed weights, weighted combination, sign. Identical arithmetic to steps 4 through 6, on a K that was built a completely different way. The outputs: Linear K, first column = [13, 25, 12, 15, 19, 27] Linear decision values = 17 and 5, both positive RBF decision values = -2 and 1, so negative and positive The takeaway: the kernel is the only thing that changed, and it changed the answer. The linear SVM calls both test vectors positive; the RBF one splits them. Everything after the kernel matrix, the signed weights and the weighted combination and the sign, is the same page of arithmetic twice. 💾 Save this post!

SVM by hand ✍️ ~ 19 steps walkthrough below (Linear vs RBF) Support Vector Machines reigned supreme in machine learning before the deep learning revolution. An SVM predicts with dot products, the same matrix multiplication every model uses. What it does not do is train by backpropagation: it is fitted by convex optimization, so there is no matrix-multiplication backward pass for a GPU to accelerate. I drew and calculated two SVMs by hand: a linear one (top) and an RBF one (bottom), classifying the same two test vectors. Goal: turn six training vectors and their learned coefficients into a prediction, and see what changing the kernel actually changes. = 1. Given = Six training vectors, their labels, and the coefficients and bias already learned. A coefficient of zero means that vector is not a support vector: too far from the boundary to matter. = 2. Linear kernel, test vector 1 = Let us take the dot product of the test vector with every training vector. The dot product stands in for cosine similarity, and the column of results is the first column of the kernel matrix K. = 3. Linear kernel, test vector 2 = We do the same for the second, and K is complete. = 4. Signed weights = Let us multiply each coefficient by its label. The second training vector drops out here, because its coefficient is 0. = 5. Weighted combination = We multiply the signed weights through K and add the bias b. The result is a signed distance to the decision boundary: 17 and 5. = 6. Classify = Let us take the sign. Both are positive. = 7 to 11. RBF kernel, test vector 1 = Now the same picture with a different kernel, in five moves: square the differences, sum them, take the square root for the L2 distance, multiply by minus gamma, and raise e to that power. The negation is what turns a distance into a similarity, and gamma controls how far a single training vector's influence reaches. = 12 to 16. RBF kernel, test vector 2 = We repeat all five. The numbers change, the moves do not. = 17 to 19. Decision boundary, again = Signed weights, weighted combination, sign. Identical arithmetic to steps 4 through 6, on a K that was built a completely different way. The outputs: Linear K, first column = [13, 25, 12, 15, 19, 27] Linear decision values = 17 and 5, both positive RBF decision values = -2 and 1, so negative and positive The takeaway: the kernel is the only thing that changed, and it changed the answer. The linear SVM calls both test vectors positive; the RBF one splits them. Everything after the kernel matrix, the signed weights and the weighted combination and the sign, is the same page of arithmetic twice. 💾 Save this post!

Tom Yeh

16,916 görüntüleme • 1 ay önce

RedNova: From Arbitrary File Write to Command Execution Using COM in Windows Months ago, I wrote a post ( about the unique method used in the RedSun exploit to turn a file write into command execution by using a COM object that can be triggered by a low-privileged user and runs as SYSTEM. In that post, I mentioned that there are other COM objects that can be used in the same way. I presented one object called CoFilterPipeline and noted that it needs some tricks before it can be weaponized. Now I've written a full blog post on how you can find such objects and how you can weaponize them in exploits like RedSun. The video below shows another COM object with the same behavior (windows 11). It's called PerceptionSimulationCoClass. A low-privileged user can activate it, and it runs as SYSTEM. The video doesn't contain any exploit (it just replaces the COM server as administrator). The goal is only to demonstrate how a file write can be turned into command execution as SYSTEM while being triggered by a low-privileged user.

RedNova: From Arbitrary File Write to Command Execution Using COM in Windows Months ago, I wrote a post ( about the unique method used in the RedSun exploit to turn a file write into command execution by using a COM object that can be triggered by a low-privileged user and runs as SYSTEM. In that post, I mentioned that there are other COM objects that can be used in the same way. I presented one object called CoFilterPipeline and noted that it needs some tricks before it can be weaponized. Now I've written a full blog post on how you can find such objects and how you can weaponize them in exploits like RedSun. The video below shows another COM object with the same behavior (windows 11). It's called PerceptionSimulationCoClass. A low-privileged user can activate it, and it runs as SYSTEM. The video doesn't contain any exploit (it just replaces the COM server as administrator). The goal is only to demonstrate how a file write can be turned into command execution as SYSTEM while being triggered by a low-privileged user.

Haidar

13,588 görüntüleme • 24 gün önce

Cardano has a liquidity problem! A new design called the DeFi Kernel aims to fix this by turning Cardano into a single shared liquidity layer In this video, I break down the trade-offs & which model is actually better from a user perspective: The old DeFi model vs the new one

Cardano has a liquidity problem! A new design called the DeFi Kernel aims to fix this by turning Cardano into a single shared liquidity layer In this video, I break down the trade-offs & which model is actually better from a user perspective: The old DeFi model vs the new one

Linda

13,009 görüntüleme • 4 ay önce

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

Yarchi

58,549 görüntüleme • 3 ay önce

THE HEAD ENGINEER AT ANTHROPIC LEAKED A SETUP WHERE ONE FILE TURNS INTO A FINISHED PRODUCT IN 24 HOURS you hire nobody - you paste a $3.2M file into Fable 5, and the system unrolls itself from there. root → wiring → 4 branches → tests → release → back into the root in the first hour you write 4 things: boundaries, stack, roles, escalation - everything downstream is a consequence of that file. the first 5 hours the system wires itself into tools and only then decides what to build - a team would spread that across two weeks. 8 straight hours run 4 parallel branches with zero meetings - the same block a team fills with standups. by the time you finally open the diff, tests and the critic have already rejected it twice. the changelog is written by the run, not by a human from memory - so it never falls behind the code. your total involvement across the day is exactly 2 hours: the first one, and the one where you say ship it. the 9 hours you were asleep weren't downtime, they were capacity - a queue you have to launch by hand becomes your monday. and the key part: at 05:00 the report rewrites that same root - what shipped, what got rejected, what it cost. without that last line this is just a schedule - with it, the schedule improves itself. save this and paste it into Claude Code - and tomorrow starts from a better file than today did ↓

THE HEAD ENGINEER AT ANTHROPIC LEAKED A SETUP WHERE ONE FILE TURNS INTO A FINISHED PRODUCT IN 24 HOURS you hire nobody - you paste a $3.2M file into Fable 5, and the system unrolls itself from there. root → wiring → 4 branches → tests → release → back into the root in the first hour you write 4 things: boundaries, stack, roles, escalation - everything downstream is a consequence of that file. the first 5 hours the system wires itself into tools and only then decides what to build - a team would spread that across two weeks. 8 straight hours run 4 parallel branches with zero meetings - the same block a team fills with standups. by the time you finally open the diff, tests and the critic have already rejected it twice. the changelog is written by the run, not by a human from memory - so it never falls behind the code. your total involvement across the day is exactly 2 hours: the first one, and the one where you say ship it. the 9 hours you were asleep weren't downtime, they were capacity - a queue you have to launch by hand becomes your monday. and the key part: at 05:00 the report rewrites that same root - what shipped, what got rejected, what it cost. without that last line this is just a schedule - with it, the schedule improves itself. save this and paste it into Claude Code - and tomorrow starts from a better file than today did ↓

Sprytix

20,510 görüntüleme • 1 ay önce

"Technical writing completely changed my life." - Thariq is on vacation In less than 2 years, Thariq (Anthropic) cracked the code on writing technical articles that consistently pass 1M+ views. In this 15-min workshop, he breaks down: → his exact writing workflow → tactics behind articles that go viral → how he leverages AI to write faster (without losing his voice) → why technical writing is the most underrated way to drive mindshare Technical writing is one of the most powerful (and completely free) ways to gain views, build authority, and teach the world what you know. This is the 4th [Technical] Write & Learn, a curated workshop series cohosted with swyx and Kernel Labs.

"Technical writing completely changed my life." - Thariq is on vacation In less than 2 years, Thariq (Anthropic) cracked the code on writing technical articles that consistently pass 1M+ views. In this 15-min workshop, he breaks down: → his exact writing workflow → tactics behind articles that go viral → how he leverages AI to write faster (without losing his voice) → why technical writing is the most underrated way to drive mindshare Technical writing is one of the most powerful (and completely free) ways to gain views, build authority, and teach the world what you know. This is the 4th [Technical] Write & Learn, a curated workshop series cohosted with swyx and Kernel Labs.

Sarah Chieng

268,019 görüntüleme • 4 ay önce

you told it something in the middle of a session, and an hour later it behaved like you never had you were not forgotten, you were never written down an instruction can live in three places and compaction treats them differently: the project root file is re-read from disk and put back, a nested one or a path scoped rule comes back only when the model next opens a file it applies to, and anything you only said out loud comes back never so the rule you typed most recently, in the moment it mattered most, is the one with the shortest life in the room you thought you were configuring it you were talking to it one of those survives the summary

you told it something in the middle of a session, and an hour later it behaved like you never had you were not forgotten, you were never written down an instruction can live in three places and compaction treats them differently: the project root file is re-read from disk and put back, a nested one or a path scoped rule comes back only when the model next opens a file it applies to, and anything you only said out loud comes back never so the rule you typed most recently, in the moment it mattered most, is the one with the shortest life in the room you thought you were configuring it you were talking to it one of those survives the summary

Lagosaur

10,263 görüntüleme • 8 gün önce

U-Boot menu now works on Flipper One Now you can choose different kernels and systemd targets before the Linux kernel boots. * It's our LCD/buttons driver plus a slightly modified vanilla U-Boot menu. Will try to upstream it to U-Boot. * This is a temporary solution for testing the selection of different OS profiles. In the final version of Flipper OS, we’ll most likely draw the boot menu using a small program compiled into initramfs, after the kernel has started. But as a temporary solution, it works perfect. * I’m still not happy with the cold boot time: from powering on the processor to having a working menu. Here’s the boot log with timestamps, captured from the processor console: * Our patched U-Boot:

U-Boot menu now works on Flipper One Now you can choose different kernels and systemd targets before the Linux kernel boots. * It's our LCD/buttons driver plus a slightly modified vanilla U-Boot menu. Will try to upstream it to U-Boot. * This is a temporary solution for testing the selection of different OS profiles. In the final version of Flipper OS, we’ll most likely draw the boot menu using a small program compiled into initramfs, after the kernel has started. But as a temporary solution, it works perfect. * I’m still not happy with the cold boot time: from powering on the processor to having a working menu. Here’s the boot log with timestamps, captured from the processor console: * Our patched U-Boot:

Flipper R&D

33,407 görüntüleme • 2 ay önce

IN 1982 GRACE HOPPER WALKED INTO THE NSA AND EXPLAINED THE NEXT 40 YEARS OF COMPUTING 48 minutes from the woman who invented the compiler -- the first person who made a machine understand human words. -> The idea that lands: stop bending humans to the machine. Bend the machine to humans. She built the first compiler when the experts swore computers could only crunch numbers. She wanted you to write in plain words and let the machine handle the translation. Forty years later you barely write code at all -- you tell the model what you want in plain English and it writes it for you. The compiler was step one. The LLM is the same idea, finished. Memorizing syntax was never the skill -- saying clearly what you actually want is. This is where that idea was born. Most people think talking to your computer in plain English started in 2023. The ones who watch this know a Navy admiral called it in 1982. Bookmark & Watch it today ↓

IN 1982 GRACE HOPPER WALKED INTO THE NSA AND EXPLAINED THE NEXT 40 YEARS OF COMPUTING 48 minutes from the woman who invented the compiler -- the first person who made a machine understand human words. -> The idea that lands: stop bending humans to the machine. Bend the machine to humans. She built the first compiler when the experts swore computers could only crunch numbers. She wanted you to write in plain words and let the machine handle the translation. Forty years later you barely write code at all -- you tell the model what you want in plain English and it writes it for you. The compiler was step one. The LLM is the same idea, finished. Memorizing syntax was never the skill -- saying clearly what you actually want is. This is where that idea was born. Most people think talking to your computer in plain English started in 2023. The ones who watch this know a Navy admiral called it in 1982. Bookmark & Watch it today ↓

slash1s

61,013 görüntüleme • 2 ay önce

The job of a marketing engineer is to pull signals into one system and turn them into pipeline. Here is an example of an SEO/AEO workflow: 1) Read Google Search Console 2) Pull the keyword data from Ahrefs or SEMrush 3) Look in the CMS to find out if the post is already there 4) Put the keywords in order by search volume and buyer intent 5) Read the pages that are at the top of the results now 6) Add the founder's point of view 7) Write the post, the meta title and the internal links Then the agent sends all of it to a person for approval. The agent can only do this if you connect it to your live business data and your tools. "The tools are going to keep changing, but the workflow is the thing to actually learn." Learn the workflow first.

The job of a marketing engineer is to pull signals into one system and turn them into pipeline. Here is an example of an SEO/AEO workflow: 1) Read Google Search Console 2) Pull the keyword data from Ahrefs or SEMrush 3) Look in the CMS to find out if the post is already there 4) Put the keywords in order by search volume and buyer intent 5) Read the pages that are at the top of the results now 6) Add the founder's point of view 7) Write the post, the meta title and the internal links Then the agent sends all of it to a person for approval. The agent can only do this if you connect it to your live business data and your tools. "The tools are going to keep changing, but the workflow is the thing to actually learn." Learn the workflow first.

The Startup Ideas Podcast (SIP) 🧃

23,531 görüntüleme • 15 gün önce

ANTHROPIC LEAKED A SETUP WHERE ONE FILE STARTS 7 LOOPS THAT TURN A PROMPT INTO A WORKING BUSINESS AI engineer drops in 1 file - the other 95% of the work closes automatically without them. spec → tasks → code → tests → docs → release → monitoring → back into the spec you don't write tickets anymore - you write the thing tickets get derived from, and Opus 5 cuts the spec into 6 tasks by itself. a task that fails its test comes back to itself, not to you - and runs a second lap without a single notification. 6 lanes of code run in parallel and none of them wait on you - the critic filters the diff before you ever open it. every new production bug becomes a permanent line in the eval set - the system never steps on it twice. monitoring isn't the end of the line, it's the start of the next spec - those back edges are what make it a graph instead of a conveyor. and one place is left where you say yes - release, 5 minutes instead of 5 hours. save this and paste it into Claude Code - and you get 7 loops that run without you ↓

ANTHROPIC LEAKED A SETUP WHERE ONE FILE STARTS 7 LOOPS THAT TURN A PROMPT INTO A WORKING BUSINESS AI engineer drops in 1 file - the other 95% of the work closes automatically without them. spec → tasks → code → tests → docs → release → monitoring → back into the spec you don't write tickets anymore - you write the thing tickets get derived from, and Opus 5 cuts the spec into 6 tasks by itself. a task that fails its test comes back to itself, not to you - and runs a second lap without a single notification. 6 lanes of code run in parallel and none of them wait on you - the critic filters the diff before you ever open it. every new production bug becomes a permanent line in the eval set - the system never steps on it twice. monitoring isn't the end of the line, it's the start of the next spec - those back edges are what make it a graph instead of a conveyor. and one place is left where you say yes - release, 5 minutes instead of 5 hours. save this and paste it into Claude Code - and you get 7 loops that run without you ↓

Sprytix

66,333 görüntüleme • 1 ay önce

Larry Ellison just told every software engineer on Earth their job description is dead. Not evolving. Dead. Ellison: “The code that Oracle is writing, Oracle isn’t writing. Our AI models are writing.” This is not a startup demo. This is one of the largest infrastructure monopolies on the planet telling you it already replaced the people who built it. For fifty years, building software meant translating human intent into machine instructions. Line by line. Bug by bug. Sprint by sprint. That entire layer is gone. Ellison: “We don’t write the procedure. We declare our intent.” That sentence just made the entire engineering labor market flinch. The procedure was the job. The procedure was the paycheck. The procedure was what made a developer valuable. And now the machine does it without being asked twice. Ellison: “We just tell the model what we want the program to do, and then the AI comes up with a step-by-step process to actually do it.” You are no longer paid to build. You are paid to think. And most organizations have no idea how to evaluate that. The companies still hiring armies of developers to grind through codebases are paying salaries the machine already made worthless. Not in years. In seconds. When a company worth hundreds of billions hands the keyboard to the machine and tells you the output is better, the debate is not winding down. The debate is over. The enterprise that wins this decade does not write the best code. It removes the human from the process entirely and runs on intent alone. The programmers who survive are the ones who realize the craft is no longer typing. It is architecture. It is judgment. It is knowing what to build and why. Everything else now belongs to the machine. And the machine does not negotiate severance.

Larry Ellison just told every software engineer on Earth their job description is dead. Not evolving. Dead. Ellison: “The code that Oracle is writing, Oracle isn’t writing. Our AI models are writing.” This is not a startup demo. This is one of the largest infrastructure monopolies on the planet telling you it already replaced the people who built it. For fifty years, building software meant translating human intent into machine instructions. Line by line. Bug by bug. Sprint by sprint. That entire layer is gone. Ellison: “We don’t write the procedure. We declare our intent.” That sentence just made the entire engineering labor market flinch. The procedure was the job. The procedure was the paycheck. The procedure was what made a developer valuable. And now the machine does it without being asked twice. Ellison: “We just tell the model what we want the program to do, and then the AI comes up with a step-by-step process to actually do it.” You are no longer paid to build. You are paid to think. And most organizations have no idea how to evaluate that. The companies still hiring armies of developers to grind through codebases are paying salaries the machine already made worthless. Not in years. In seconds. When a company worth hundreds of billions hands the keyboard to the machine and tells you the output is better, the debate is not winding down. The debate is over. The enterprise that wins this decade does not write the best code. It removes the human from the process entirely and runs on intent alone. The programmers who survive are the ones who realize the craft is no longer typing. It is architecture. It is judgment. It is knowing what to build and why. Everything else now belongs to the machine. And the machine does not negotiate severance.

Dustin

536,136 görüntüleme • 5 ay önce

IN 1986 MIT FILMED THE LECTURE WHERE CODE STOPPED BEING CODE AND BECAME DATA 43 minutes from Gerald Sussman, in the most legendary intro programming course ever recorded. -> The idea that lands: to a program, your code is just data it can read and rewrite. He builds a program that does real calculus -- not by crunching numbers, but by reading the math as a list and transforming it piece by piece. Then he shows the trick hiding under all of it: in this language, code and data are the same material. Forty years later that is exactly what an AI coding agent is -- a program that reads your code as data, rewrites it, and hands it back. Sussman drew the whole idea on a blackboard in 1986. Writing code was never the deepest skill -- understanding that code itself is data a program can manipulate is. This is where you learn it. Most people think AI writing code is brand new. The ones who watch this saw the blueprint 40 years ago. Bookmark & Watch it. This one's a legend ↓

slash1s

22,107 görüntüleme • 2 ay önce

SemiAnalysis' Jordan Nanos reveals the OpenAI engineers scrolling their own kernel code had no idea what it did line by line, and it didn't matter because the AI does "It's not slop, because it performs, but it's literally just AI-generated assembly basically puked out in Gluon, this low-level kernel programming language that they built on top of Triton, which uses this really interesting programming model." "The point is, the guys who were scrolling through this code with us, it was kind of clear that they know a whole bunch about hardware, they know a whole bunch about the concepts in the system, and they just have no idea what this MLA kernel that they're showing us for DeepSeek actually does." "You can go line by line and it's like nope, nope, nope." "But it doesn't matter. The AI understands it, the AI tests it, and you see the results. It produces correct kernels that perform really well." "And I think this is just a sign of what's to come again." "That actual code is not necessarily something that a human has to reason about deeply, if the AI knows how to manipulate the data movement and the processing elements on the hardware that you've given it." ________ More takeaways from OpenAI's Jalapeno development:

SemiAnalysis' Jordan Nanos reveals the OpenAI engineers scrolling their own kernel code had no idea what it did line by line, and it didn't matter because the AI does "It's not slop, because it performs, but it's literally just AI-generated assembly basically puked out in Gluon, this low-level kernel programming language that they built on top of Triton, which uses this really interesting programming model." "The point is, the guys who were scrolling through this code with us, it was kind of clear that they know a whole bunch about hardware, they know a whole bunch about the concepts in the system, and they just have no idea what this MLA kernel that they're showing us for DeepSeek actually does." "You can go line by line and it's like nope, nope, nope." "But it doesn't matter. The AI understands it, the AI tests it, and you see the results. It produces correct kernels that perform really well." "And I think this is just a sign of what's to come again." "That actual code is not necessarily something that a human has to reason about deeply, if the AI knows how to manipulate the data movement and the processing elements on the hardware that you've given it." ________ More takeaways from OpenAI's Jalapeno development:

Fireside Alpha

4,520,741 görüntüleme • 18 gün önce