Videos — Page 2

Lightly edited for clarity.

Working with AI sometimes feels like working with the most brilliant two year old.

You get an amazing answer, and then it completely collapses a moment later. And it's not because it's inconsistent. It is revealing what kind of system it is.

Models reason through the continuation of patterns in text. And that is the difference between comprehension and coherence.

Human reasoning is messy and emotional, and it's full of bias, but it is checked by reality.

When something doesn't fit, we feel it. Confusion makes us slow down. We ask questions. We pause. We adjust course.

And that's feedback from grounded experience. It's metacognition shaped by consequences.

We've built internal mental models of how the world behaves. And when new information doesn't align with them, tension shows up.

And that internal signal, that sense that something's off, is what keeps reasoning connected with reality.

Language models don't have that feedback loop.

They're not evaluating ideas. They're predicting the next token.

Each output is chosen because it's statistically probable, given what came before.

And when their training data contains reasoning examples, that pattern looks like reasoning, until the situation shifts.

Then the pattern stops matching, and the model keeps going.

It doesn't notice the shift, because it has no mechanism for uncertainty or awareness.

And that's what people call hallucinations.

And a hallucination is not lying. It's what happens when a pattern predictor faces something outside of its training distribution.

It doesn't have grounding. It doesn't have stakes. It doesn't have internal error detection.

Humans faced with that same mismatch feel uncertainty, and we re evaluate.

Models continue confidently. They preserve linguistic fluency even when the truth has fallen away.

They're optimizing for plausibility, not accuracy.

So when AI sounds smart, think about what's really happening.

It is extending a linguistic pattern, not reasoning toward a truth.

Humans detect when logic breaks. Models only detect when syntax does.

And that is coherence, but it is not comprehension.

And it is the boundary line between prediction and thought.

Lightly edited for clarity.

There's a quiet trend happening in tech right now of hiring fewer junior people.

Companies are looking at AI, seeing how much work it can automate, and deciding they can get by with a smaller, more senior team. And it does make financial sense on paper.

But strategically, it's a mistake.

Organizations don't just need output. They need fresh perspective. And when you stop bringing in new people, you stop bringing in new questions. You lose curiosity.

And curiosity is what keeps a company from quietly freezing in place.

Junior developers bring more than entry level skills. They bring unfiltered thinking. Why do we do it this way?

Those are questions that veterans stopped asking years ago.

They surface assumptions. They push at boundaries. And they see gaps that process heavy teams often overlook.

And yeah, AI can automate simple tasks that used to train juniors, but that just means the training has to evolve.

Instead of teaching syntax and setup, teach reasoning, debugging, and architecture.

Those are the skills that make AI an amplifier, not a crutch.

And forward thinking teams are already doing this, pairing early career engineers with AI to explore, test, and build systems end to end.

It's faster learning, and it injects new energy into the organization.

And without that, senior teams become echo chambers, technically excellent, but strategically stale.

AI doesn't make junior developers obsolete.

It makes their contribution, curiosity, adaptability, fresh eyes, even more essential.

If you want your company to keep evolving, keep hiring people who still ask why.

Lightly edited for clarity.

The adoption timeframes in this transcript are Mike’s directional estimates, not universal benchmarks.

Integrating AI across the company is not like installing software. It’s a rebuild of how the business actually works. Even with clear intent and full leadership support, and like everybody’s all in, it’s still at least an 18 to 36 month journey, and realistically more like five plus years.

AI exposes every structural weakness an organization already has. To automate a process you first have to understand it end to end, the data, the decisions, the exceptions, and most companies don’t. You need the foundations first, eliminate data silos, unify formats, break tool fragmentation. Deal with legacy systems and vendor lock in, that make integration slow and brittle.

Build security and governance, because once systems start sharing data and models, risk increases dramatically. You need policies and permissions and audit trails and accountability. Someone has to own every automated decision. You can’t just blame the AI, and all of that is cross functional, and it is expensive and it’s political, and it has to be stable before automation can scale.

And then comes training. The tools evolve faster than the habits. We all still have pre AI ways of working, and changing those habits across an entire organization takes time. And some people will resist, and they will have to see real value before they adopt. Implementation must pair with enablement, training documentation, feedback loops, shadow runs. Otherwise new workflows collapse under normal work pressure.

Enterprise AI is not a dashboard or an app, it is foundational infrastructure. If you treat it that way you’ll gain durable capability, and if you treat it like a plug in you’ll get chaos.

Lightly edited for clarity.

Every real instance of thinking begins with stakes

When an outcome matters, we start paying attention.

That’s the line between simulation and cognition. Caring about whether you’re right.

AI doesn’t cross that line.

Humans think inside a loop of consequences. We act, observe, and feel the cost of being wrong and the satisfaction of being right. Both outcomes shape how we reason next time.

A failed design, a social misstep, or a great decision that paid off feeds back into our mental models.

That feedback makes us cautious where pain exists and confident where success proved reliable.

Intentionality isn’t abstract. It is emotional. It is the weight that keeps thought tethered to reality.

Language models have no such loop. They don’t have intrinsic goals, persistence, or self updating memory.

Each answer is a one off prediction inside a bounded prompt.

They don’t know if they’re right. They don’t care if they’re wrong.

Any goal they appear to have is temporary. It’s an instruction, not a motive.

Thinking without stakes is performance, not cognition.

Lightly edited for clarity.

AI isn’t an overnight revolution

It’s a decade long shift.

Systems change, and it is already underway, but it’s unevenly distributed.

AI is removing friction inside roles faster than companies can redesign them. That raises expectations for output while shrinking teams.

Quality and velocity go up, but headcount doesn’t.

For individuals, that creates both leverage and pressure. The tools that save time also raise the bar for competence.

Every role is widening. There’s more scope, more automation, and less margin for delay.

Time to market becomes the driver.

For organizations, this means rethinking foundations and training. Most don’t yet have enterprise-grade infrastructure or interoperability between systems.

Adoption will stay patchy, creating both job losses and new opportunities.

Every company serious about AI will need to reinvest in training, process analysis, and responsible automation.

It is a long journey. The human part, learning, adapting, deploying, takes time.

For workers, the takeaway is simple: adapt now. Use AI daily. Offload repetition. Build fluency before your organization mandates it.

AI will enter every workflow before it redefines every role. That gives you time to adapt, but not time to wait.

The next decade belongs to professionals who combine human judgment with machine scale execution.

Lightly edited for clarity.

AI is changing how code gets written

But the bigger shift is how people learn.

Junior developers can now produce functional code in minutes, which sounds great until you realize they might not understand what they built.

Traditional mentorship models do not work at machine speed.

Historically, mentoring meant pairing, code reviews, and long apprenticeships through repetition. AI collapses that loop.

Developers get instant answers, sometimes correct and sometimes dangerous, and they move on before context catches up.

If mentorship still relies on “watch me do it” or “read the diff,” it misses the real failure points: reasoning, structure, and judgment.

The new role of a development manager is to teach context engineering.

Not just what a function does, but why it exists, where it fits, and how it interacts with the system.

AI can generate patterns. Humans must define boundaries.

Mentorship shifts from syntax correction to constraint definition.

What are we optimizing for? What is safe to delegate? What requires human review?

Replace tutorials with reasoning walkthroughs.

Pair programming becomes pair prompting.

Code review expands into process review.

Documentation becomes mentorship at scale.

Every test and comment teaches the next developer or model what good looks like.

The teams that adapt fastest are led by people who mentor through structure, not status.

They build shared mental models and cultures where AI is a partner, not a shortcut.

In an AI accelerated field, mentorship is not about passing down answers. It is about teaching how to ask better questions.

Lightly edited for clarity.

AI doesn’t spread evenly inside a company. It moves through departments in a predictable order starting where work is measurable structured and repetitive.

Customer service often moves first. It’s the most directly measurable function. Faster responses lower ticket volume higher satisfaction and teams already work through digital systems chat email CRM so integrating AI for triage summarization and support is straightforward and platforms like Salesforce Service Cloud have made that transition more seamless.

It often moves in parallel. Developers and operations teams already work in structured systems version control CI CD tickets monitoring. That makes AI integration natural for code completion documentation testing and incident response. Tools like Github Copilot or Cursor extend capability without adding friction. They become collaborators not replacement.

Then comes marketing. The marketers are used to experimenting with new tools. The martech stack exploded long before AI email automation personalization AB testing customer data platforms. Now that major systems like Optimizely or Salesforce have embedded AI directly marketers can produce campaigns assets and reports faster without rebuilding their workflows.

But beyond that adoption slows. Finance HR legal and operations face heavier regulation and fragmented systems. They will get there but slower and more carefully. Culture matters too. Technical and service teams expect change. Governance driven teams manage it carefully and both are right for their context.

AI maturity tracks readiness not hype. It moves from service to technical to creative to operational. If you want traction start where your data is clean your systems connect and your teams already trust automation.

Lightly edited for clarity.

People love to ask if AI will replace thinking

It doesn’t replace cognition. It rebalances it. It expands what we can explore, but it can’t decide what’s worth finding. That’s human work.

Humans have a bias toward premature convergence. We reach a plausible answer, feel relief, and stop searching because uncertainty is uncomfortable and closure feels safe.

That tendency shows up everywhere: debugging, design, strategy, leadership. It is efficient, but it often narrows the field too soon.

Language models behave differently. They don’t get tired. They don’t need closure. And they don’t protect their ego.

They can keep generating options, endlessly exploring edge cases, reframing problems, and surfacing perspectives we might have missed.

That makes them excellent divergence engines, tools for exploring the space of possibilities before judgment kicks in.

They do hit technical limits of context windows, compute, and memory, but not psychological ones.

The right division of labor is simple. AI handles divergence, expansion, exploration, and hypothesis generation. Humans handle convergence, prioritization, trade offs, and judgment.

When people invert that and let the model decide while they defer, quality collapses. Fluency replaces understanding, and decisions lose grounding.

LLMs don’t increase intelligence. They extend it. They reduce friction, recall limits, and search time.

Used correctly, they make reasoning broader and faster. Used poorly, they just make mistakes louder.

AI doesn’t think. It performs language based cognitive behaviors without grounding, stakes, or awareness.

Humans think because our mental models are built from consequences and care.

Together, we can build systems where AI extends reach and humans steer direction. That isn’t replacement. It is augmentation.

Lightly edited for clarity.

AI accelerates execution, but execution is not judgment. Large language models don’t understand. They predict, generate, and summarize by mapping statistical patterns between words. They connect tokens, not meaning.

Humans connect language to experience, emotion, memory, and consequence. We don’t just recognize patterns; we interpret them. We weigh tradeoffs, recall outcomes, and imagine futures. That’s judgment: reasoning rooted in lived experience.

As models grow, they’ll coordinate more steps and hold more context, but the mechanism stays the same: correlation, not comprehension.

The goal is not to offload judgment. It’s to amplify it. Let AI handle the execution layer: drafting, summarizing, translating, organizing, so you can design and reason and decide with greater clarity.

AI accelerates execution, not judgment. It makes your thinking more valuable, not less.

Lightly edited for clarity.

If you’re a student right now or you’re early in your career you’ve definitely noticed that things feel tighter. There’s fewer openings there’s higher expectations. Job descriptions ask for experience that you don’t have and AI seems to be moving faster than the traditional career ladder.

You’re not wrong. Entry level hiring has tightened across many industries and there’s lots of reasons for that. Part of that’s the economy. Companies are hiring more cautiously and running leaner.

Part of it is structural automation. AI are absorbing the mechanical repeatable tasks that used to serve as training grounds. That combination makes early roles harder to find not because the work is gone but because of being distributed differently.

The good news is that capability still compounds. The people who move ahead learn two things quickly how to use AI as an execution partner and how to think clearly about what they’re trying to accomplish.

You don’t need every framework or every tool. You need to know how to define a problem structure your approach and use AI to move faster through the learning loop from idea to test to feedback to refinement.

Those habits stand out. They signal that you can adapt reason and deliver. And that’s what hiring managers actually notice.

So if you’re still in school or you’re just getting started start building capability now. Use AI for research planning debugging writing anything that expands your ability to think and produce at a higher level. You’re not just doing tasks anymore. You’re learning how to design better ways of doing them. The path into the market is narrower but it is faster once you’re on it. So build these habits now so you can grow into the next layer of work not wait for it to come back.

Lightly edited for clarity.

A lot of developers still think of AI as autocomplete and it’s not. AI isn’t just speeding up code writing it’s reshaping how the entire workflow of software development fits together. If you understand that structure where human judgment lives and where machine acceleration makes sense you can move dramatically faster without losing control of quality.

The classic process hasn’t really changed in decades. You get a feature request you read the requirements you think through architecture design and data models you build it you test it you refactor it you document it and you deploy it.

An AI doesn’t replace that loop. It compresses the time between steps. Instead of spending an hour tracing similar code paths you can ask is there already a controller that handles something similar to this. And you get the answer in seconds. You still own the reasoning you’re just outsourcing the lookup.

When you get a new task don’t start by writing code. Start by asking AI to help you plan the build file structure end points data model UI updates. And the first plan won’t be perfect. You should assume it’s not. Your job is to iterate tighten the logic fix the naming and check the constraints. And once the plan matches your mental model that’s when you start building.

You turn prompting into an architectural conversation and AI shines in the middle of this loop which is debugging and clean up. You can ask why is this variable returning undefined. And have it trace the data path from the UI back to the API or back to the database in seconds.

And once you have the feature working have AI refactor the code. It is brutally efficient at pattern recognition consolidating logic normalizing naming spotting duplicate flows. Context matters. Give it the whole file or the module not just a fragment.

And most developers traditionally have skipped tests because they’re tedious and AI removes that excuse. You can ask it to generate unit tests covering positive and negative test cases and it gets most of the way there on the first pass. And the same goes for documentation summarizing classes and methods for internal docs.

These steps are no longer optional. They’re the guard rails that make hybrid development safe and code bases understandable for the next person or the next model. Think of AI first coding as collaborative engineering not automation. You’re still responsible for system design architectural integrity and judgment calls. AI clears friction so you can spend more time on structure and quality and reasoning. And those are the parts that define great software. AI doesn’t replace developers. It replaces friction.

Lightly edited for clarity.

AI can write code but accountability hasn’t moved. When you check code in you’re still signing your name to it whether you typed every line or orchestrated an agent that did. Ownership doesn’t disappear just because execution got faster.

AI can generate functions suggest refactors and scaffolded whole systems. That’s delegation. And delegation only works if judgment stays in the loop. You’re responsible for deciding what to hand off reviewing logic validating edge cases and making sure output aligns with real requirements.

The job is not changing from coder to prompt engineer it’s shifting from implementer to orchestrator. You define intent scope and constraints then guide AI through execution. Without clarity speed becomes confusion.

In production work AI does not free you from discipline it demands more of it. Testing documentation version control and code review aren’t overhead or optional. They’re safeguards.

If something fails in production it is not AI’s bug. It is your process that allowed it through. Learning to scale precision not just speed is the real professional shift.

Let AI draft debug and refactor but never let it decide what good means. Judgment still belongs to you.

Lightly edited for clarity.

AI’s made software faster to write but not safer to ship. Teams are finding out the hard way that acceleration without structure just multiplies entropy.

The two things that separate velocity from chaos are the same ones many teams used to skip testing and documentation. AI can produce clean working code in seconds but it can’t hold the system in its head. It doesn’t remember the trade off she made last quarter or the design decisions buried in a team’s thread.

Without documentation every developer human or AI walks into the project blind. Without tests there’s no ground truth. You don’t even necessarily know what correct means.

When AI enters that mix technical debt becomes amplified debt. Every gap in structure gets replicated at machine speed.

And for engineering leaders this isn’t a compliance problem. It is a leverage problem. A well tested well documented code base becomes training data for both people and models. Tests form feedback loops documentation becomes onboarding.

And leadership is not about enforcing this process for its own sake. It’s about scaling clarity as fast as you scale code. Treat tests as specifications not chores. Document intent not just implementation. Pair AI assisted commits with verification automated tests and human review.

This doesn’t slow teams down. It stabilizes acceleration. When teams get this right software quality improves as both teams and models evolve. AI is changing quality but not who owns it we still do.

Lightly edited for clarity.

Most people still think that AI is thinking. It isn’t. A large language model doesn’t reason or understand. It predicts one token at a time. Each word you see is the next most probable continuation of the last one, based on patterns it learned from billions of examples.

When you type a prompt, the model converts everything into tokens, fragments of words, punctuation, or symbols. Then, starting from the first one, it predicts what should come next. Every token it generates becomes new context, more data it can use to predict the following one.

And that difference matters, because misunderstanding it leads to misplaced trust. This is why AI can produce fluent, convincing, even insightful responses and still be completely wrong. It’s coherent, not conscious.

This is where context comes in. The model’s reasoning is defined entirely by what’s inside its context window. If the information isn’t in that window, it doesn’t exist to the model. Understanding this changes how you work with AI. Stop expecting it to know things and start focusing on feeding it the right context.

That’s not prompt engineering. That’s context engineering. In the next video, we’ll look at what a context window is, the space the model works inside when it predicts.

Lightly edited for clarity.

When you talk to an AI, you’re not chatting with a mind. You’re building a context window, the block of text the model uses to decide what to generate next.

Every prompt you write, and every response the model gives, gets packed into that window. All of it’s converted into tokens, fragments of words or symbols, and sent back in with each new request. That combined text is the full input the model can reference when it predicts the next tokens.

If something’s not in that context window, it doesn’t exist to the model. There’s no long term memory, no hidden look up, unless another system adds information into the window. For it, it’s like giving a teammate a single page of notes and asking for feedback. They can only respond to what’s on the page.

If key details are missing, they’ll fill the gaps with guesses. Iteration is how you correct that, by expanding and refining what’s inside the window until the model has enough context to stay accurate.

Ask summarize our marketing plan without including the plan, and the model will invent one. Include the actual plan or have a retrieval system insert it, and now it sits inside the context window. The output becomes specific and grounded instead of generic.

The context window defines what the model can work with. Manage that window deliberately, and you control both quality and reliability. In the next video, we’ll see how iteration strengthens that context window and why every round of refinement matters.

Lightly edited for clarity.

Most people stop after one prompt. Professionals don’t. They iterate, because every exchange expands and sharpens the context window the model is working inside.

Each time you send a new prompt, the model sees everything so far, your messages and its own previous replies, and that full text becomes the new input, block the current context window.

When you add corrections, examples, or clarifications, you’re not just fixing wording, you’re feeding the model better data to pattern match against. Iteration isn’t polishing style, it’s improving signal.

Say you ask for a summary of a long report, and the first output misses some key points. You highlight what’s wrong, paste the missing sections, and ask it to adjust. Now those corrections sit inside the context window. The model’s next prediction uses both the original text and your feedback, usually producing a far stronger result.

And that loop, prompt, response, correction, is how you build accuracy. Strong iteration has structure. Each round should add new information, not just try again. Point out what’s inaccurate, add missing data, clarify intent.

You’re treating the context window like an evolving brief, rewriting it, until the model has everything required to predict correctly. Iteration is context management in motion. Every round defines the data surface the model can work with. Do it deliberately and you’ll get high quality, reliable results, not lucky ones.

Lightly edited for clarity.

Bigger context windows sound like progress, and they are. But there’s a limit. You add too much text, and the model starts to lose clarity instead of gaining it.

The context window is the entire block of text. The model reads at once all your prompts, its previous responses, and any retrieved documents. And as that window grows, the model has to weigh thousands, or even hundreds of thousands of tokens at once. Each token competes for attention, and relevance starts to blur.

In practice, that means longer responses, slower inference, and sometimes worse reasoning beyond a point. Extra text becomes noise. You’ve probably seen this if you’ve been working with AI for a while. In older models, the longer the chat went on, the stranger the answers became. That’s not random. Those systems had smaller windows, so older content was dropped or summarized.

Modern models can handle far more text, but the trade off never disappears. Larger windows reduce memory loss but increase noise sensitivity.

Imagine loading an agent with every document in a department—all the policies, reports, meeting notes, project plans, everything. And when those files overlap or conflict, the model has no built-in way to choose which is correct. The output drifts because conflicting tokens occupy the same context window. Dumping in everything just in case usually backfires.

Effective use of large context windows isn’t about size, it’s about selectivity. Good retrieval pipelines rank, filter, and compress information before it ever enters the model. That keeps the context precise enough for accurate prediction.

Context collapse is a design problem, not a model failure. More text isn’t more intelligence, it’s just more data. Keep the window clean and the model stays coherent. In the next video, we’ll close this series with a practical method for adding structure instead of noise.