DEV Community: Sam

AI Agents Can Now Record Their Own Development Workflows

Sam — Thu, 06 Aug 2026 09:31:26 +0000

AI coding assistants like Claude Code, Cursor, and Codex have fundamentally changed how developers build software. They're great at generating code, fixing bugs, and accelerating development—but one problem still exists:

How do you document everything the AI did?

Most teams still rely on screenshots, meeting notes, or manual documentation after completing a task. Traditional screen recorders capture the session, but they don't preserve the context behind AI-assisted development.

As AI becomes part of our daily workflow, documenting how code was created is becoming just as important as the final implementation.

Why Traditional Screen Recorders Fall Short

A development session isn't just about what's visible on the screen.

Developers constantly:

Write prompts for AI assistants
Review generated code
Run terminal commands
Test applications
Debug issues
Iterate on solutions

A video recording alone doesn't make those workflows easy to review or reuse.

That's why many engineering teams are looking for tools that combine recordings with structured documentation.

The Rise of AI Agent-Native Recording

Instead of simply recording your screen, the next generation of developer tools focuses on capturing the entire AI-assisted workflow.

Imagine finishing a coding session and instantly having:

🎥 A shareable recording
📝 Structured Markdown documentation
🤝 Better collaboration with teammates
🔍 Searchable engineering knowledge

This approach makes debugging, onboarding, code reviews, and knowledge sharing much more efficient.

Why This Matters

As AI coding assistants become more autonomous, developers need better ways to preserve context rather than just outcomes.

Good documentation isn't just for humans anymore—it's also becoming valuable for AI-assisted workflows, future maintenance, and engineering collaboration.

I recently explored this idea in more detail and explained how AI agent-native recording can improve modern software development.

👉 Read the complete article here:
https://clipy.online/blogs/ai-agent-records-its-own-screen/

I'm curious to hear what other developers think.

Do you believe AI coding tools should automatically document development workflows, or is traditional screen recording still enough?

Stop Trusting AI Bug Fixes Blindly: Here's How to Verify They Actually Work

Sam — Wed, 05 Aug 2026 11:25:45 +0000

AI coding assistants like Claude Code, Cursor, GitHub Copilot, and Codex have dramatically reduced the time it takes to fix bugs. In many cases, they can identify the root cause, generate a patch, and even write tests within minutes.

But there is one question every developer should ask before merging AI-generated code:

Did the AI actually fix the problem—or did it just produce a plausible-looking patch?

Why "Looks Fixed" Isn't Good Enough

AI models are excellent at generating code that appears correct. However, software bugs often depend on context that isn't visible in a prompt:

User interactions
UI state
Browser or operating system behavior
Timing issues
Multi-step workflows
Visual regressions

Without this context, an AI agent can easily solve the wrong problem.

What an AI Needs to Verify a Fix

Instead of relying only on stack traces or screenshots, give your AI enough evidence to reproduce the issue.

A high-quality bug report should include:

Clear reproduction steps
Screen recording of the failure
Expected vs. actual behavior
Console or runtime errors (when applicable)
Relevant screenshots
Application state
Timestamps or key moments during the failure

The richer the context, the more likely the AI is to produce the correct fix. Recent research also suggests that well-localized, structured bug reports improve repair success for AI agents.

Verify the Fix Instead of Assuming It Works

Once the AI generates a patch:

Run the same reproduction steps.
Compare the new behavior with the original issue.
Check for UI regressions.
Test edge cases.
Confirm that the original bug no longer occurs.

A successful build does not necessarily mean the bug has been resolved.

Visual Proof Makes Reviews Faster

Many bugs are easier to validate visually than through logs alone.

A short recording showing:

the original issue,
the applied fix,
and the expected behavior,

gives reviewers confidence that the patch solves the right problem.

This is especially useful when collaborating asynchronously or reviewing AI-generated pull requests.

A Better Workflow

A practical AI debugging workflow looks like this:

Record the bug.
Capture the important user interactions.
Let the AI analyze the reproduction.
Generate a proposed fix.
Replay the same scenario.
Verify the result before merging.

This reduces guesswork and creates an auditable trail showing why the change was made.

Final Thoughts

AI coding agents are becoming an essential part of modern software development, but they still depend on the quality of the context we provide.

Instead of asking an AI to "fix the bug," give it enough information to understand the bug, reproduce it, and verify the outcome. The combination of structured bug reports, reproducible evidence, and human verification leads to more reliable fixes and fewer regressions.

Why Every Developer Should Record Bugs Instead of Taking Screenshots

Sam — Thu, 30 Jul 2026 07:15:31 +0000

Every developer has experienced it.

A bug gets reported with a screenshot and a short message:

"The page crashes here."

That's all.

No steps to reproduce. No browser version. No console logs. No indication of what happened before the issue appeared.

The developer spends the next 30 minutes asking follow-up questions instead of fixing the bug.

Now imagine receiving a 45-second screen recording instead.

You see every click, every form input, every browser interaction, the exact error message, and even the browser console. You understand the issue before writing a single line of code.

This simple change can dramatically improve debugging, collaboration, and productivity.

Why Screenshots Aren't Enough

Screenshots capture a single moment.

Software bugs are usually caused by a sequence of actions.

A screenshot cannot show:

Which button was clicked first
Mouse movements
Keyboard inputs
Loading behavior
Browser navigation
Animation issues
Timing problems
Console errors
Network requests
Audio issues

Developers are forced to guess what happened.

That guesswork costs time.

Every Missing Detail Creates Another Conversation

A typical bug report often looks like this.

QA: Login page is broken.

Developer:Which browser?

QA: Chrome.

Developer: Which version?

QA: Latest.

Developer: What were you doing before this happened?

QA: I clicked Login.

Developer: What happened after clicking?

QA: Nothing.

Developer: Can you reproduce it?

QA: Let me check...

This cycle continues for several messages.

Instead of fixing bugs, everyone spends time explaining them.

Screen Recordings Tell the Complete Story

A short recording provides everything developers need.

Within one minute, the viewer can understand:

How the issue started
Exact reproduction steps
Browser interactions
Mouse clicks
Scrolling behavior
Form inputs
Error messages
Console output
Unexpected UI behavior
Timing issues

There is no guessing.

Only context.

Why Visual Context Matters

Modern applications are interactive.

Many issues cannot be explained using static images.

Examples include:

Dropdown menus disappearing
Infinite loading
Broken animations
Incorrect redirects
Responsive layout issues
Drag-and-drop failures
Video playback bugs
Payment flow interruptions

These problems only become obvious when someone watches the workflow.

Visual context allows developers to reproduce issues much faster.

AI Coding Assistants Still Need Better Context

Many teams now use AI coding assistants such as Claude Code, Cursor, GitHub Copilot, and ChatGPT.

These tools can generate code quickly.

But AI still depends on the information you provide.

A screenshot usually lacks enough context for useful troubleshooting.

A screen recording, on the other hand, shows the entire workflow—from user actions to browser behavior and error messages—making it easier for developers to understand the issue and use AI tools more effectively during debugging.

Better input leads to better suggestions.

A Better Bug Reporting Workflow

Instead of sending multiple screenshots:

Reproduce the issue.
Record the screen while explaining the problem.
Show the browser console if relevant.
Include the Network tab for API failures.
Narrate the expected behavior.
Share the recording with the team.

That's it.

One recording often replaces dozens of chat messages.

Benefits for the Entire Team
Developers
Faster debugging
Fewer clarification requests
Easier issue reproduction
Better understanding of complex bugs
QA Engineers
More accurate bug reports
Less repetitive documentation
Faster validation
Product Managers
Better visibility into customer issues
Easier prioritization
Improved communication with engineering
Customer Support

Instead of collecting screenshots from users, support teams can request a short recording, making it much easier to understand and resolve reported problems.

Choosing the Right Recording Tool

The best bug-reporting tools should make recording and sharing effortless. Look for features such as:

Browser-based recording
No complicated setup
Quick shareable links
Audio narration
Browser tab or full-screen capture
High-quality video
Fast uploads

For teams that want a lightweight, browser-first workflow, Clipy provides a simple way to capture and share bug reports without installing heavy desktop software.

Small Change, Big Impact

Switching from screenshots to screen recordings doesn't require changing your development process.

It only changes how issues are communicated.

Teams that adopt visual bug reporting often notice:

Faster issue resolution
Better collaboration
Less back-and-forth communication
Clearer documentation
Improved onboarding for new developers
More efficient remote teamwork

Even a 30-second recording can save far more time than a long thread of messages.

Final Thoughts

Software development is becoming increasingly collaborative, distributed, and AI-assisted. As applications grow more interactive, screenshots alone often fail to capture the information developers need.

Recording bugs instead of taking screenshots gives your team richer context, reduces misunderstandings, and helps everyone—from QA to engineering—work more efficiently.

The next time you find a bug, skip the screenshot.

Record it instead.

Two ways to install Jenkins

Sam — Wed, 05 Jul 2023 08:13:06 +0000

Step to install jenkins on AWS
How can you easly setup jenkins on AWS ec2 instance(Ubuntu)

Step 1
Install java

Update your system
sudo apt update

Install java
sudo apt install openjdk-11-jre

Validate Installation
java –version

It should look something like this
openjdk 11.0.17 2022-10-18
OpenJDK Runtime Environment (build 11.0.17+8-post-Ubuntu-1ubuntu222.04)
OpenJDK 64-Bit Server VM (build 11.0.17+8-post-Ubuntu-1ubuntu222.04, mixed mode, sharing)

Step 2
Install Jenkins
Just copy these commands and paste them onto your terminal.
curl -fsSL https://pkg.jenkins.io/debian/jenkins.io.key | sudo tee \ /usr/share/keyrings/jenkins-keyring.asc > /dev/null echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \ https://pkg.jenkins.io/debian binary/ | sudo tee \ /etc/apt/sources.list.d/jenkins.list > /dev/null

Add Repository Key
You have to add Jenkins repository into Ubuntu server, use below command for that.
wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -Add Package Repository
Use below command to add package repository
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
Now, to update the server you have to use below command;
sudo apt update

Now, you can use below command to install Jenkins
sudo apt install jenkins -y
Once jenkins installation completed you have to start Jenkins service for that use below command
sudo systemctl start jenkins sudo systemctl status jenkins

Unlock jenkins
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
And get the password.

Install jenkins using Docker
First of all stop all the running jenkins

Check the status of running jenkins

sudo systemctl status jenkins

Install docker first.

Command to install docker

sudo apt install docker.io Y

Command to install jenkins using docker

sudo docker pull jenkins/jenkins

sudo docker run -d -p 8080:8080 docker.io/jenkins/jenkins:latest

Now you can access jenkins with port 8080
Ip address of your instance:8080(http://54.178.81.5:8080/)

Now we have to unlock jenkins first

How to get the password

sudo docker exec -it <container_id> bash //come inside the container

cd /var/jenkins_home/secrets
cat initialAdminPassword

And get the password and copy paste into jenkins and install all the suggested password.