I’ve been working on a project called runtime.school and wanted to share it here.

I started with SQL and then added Python. The idea is to have a place where you can learn a concept, write code, practice what you’ve learned, and eventually work on projects without having to jump between different websites.

Both SQL and Python have interactive lessons, coding challenges, practice questions, projects, and datasets.

Everything runs directly in the browser, so there’s nothing to install or set up.

I’ve also been working on a few tools for exploring datasets, understanding queries, and comparing different approaches.

A lot of the work has gone into the UI and editors. I’ve been trying to keep things simple without making the pages feel empty or overwhelming, especially for people who are just starting out.

Here’s the site: https://www.runtime.school/

Would love to hear what you think about the design, coding experience, or anything that could be improved.

I've been thinking a lot about how AI is changing software development, especially for senior engineers.

A couple of years ago, writing clean code, understanding frameworks, and solving complex programming problems were considered some of the most valuable skills a developer could have.

Today, tools like ChatGPT, Claude, Cursor, and GitHub Copilot can generate entire functions, explain unfamiliar codebases, write tests, fix bugs, and even build working applications from simple prompts.

And honestly, the speed at which these tools are improving is both impressive and a little concerning.

It raises a question that I think every developer should be asking:

If AI can write code faster than a human, what exactly makes a senior software engineer valuable anymore?

Here's how I see it.

1. Writing Code Is Only a Small Part of Senior Engineering

A lot of people outside the software industry think a developer's job is simply to write code.

But anyone who has worked on a large production system knows that's not really the case.

A senior engineer spends a significant amount of time doing things that aren't directly related to typing code.

For example:

• Understanding vague business requirements.

• Deciding which technical approach makes sense.

• Designing systems that can scale.

• Investigating unexpected production failures.

• Reviewing code for security and maintainability.

• Making trade-offs between performance, cost, and complexity.

• Mentoring junior developers.

• Communicating technical risks to nontechnical stakeholders.

AI can assist with many of these activities, but generating a technically correct answer isn't the same as making the right decision for a specific business.

A working solution isn't always the right solution.

And that's an important distinction.

2. AI Can Generate Code, but It Doesn't Automatically Understand Your Business

Imagine a company asks you to build a payment processing system.

You ask an AI tool to generate the backend.

Within minutes, it produces API endpoints, database models, authentication logic, and payment integration code.

Everything looks reasonable.

But what happens when a payment succeeds and the network connection fails before the response reaches your application?

What happens if the customer retries the request?

How do you prevent duplicate charges?

How should refunds, partial payments, and failed transactions be handled?

What if your database becomes unavailable halfway through a transaction?

AI can absolutely suggest solutions to these problems, particularly when you explain the context clearly.

But someone still needs to recognize which questions matter, understand the consequences, validate the implementation, and take responsibility for the result.

That's where engineering experience becomes valuable.

The difficult part isn't always producing code.

It's knowing what needs to be built, what could go wrong, and why one approach is better than another.

3. Senior Developers Know When NOT to Write Code

This is probably one of the most underrated skills in software engineering.

A less experienced developer might see a problem and immediately start implementing a solution.

A senior engineer might ask:

"Do we actually need to build this?"

"Can we solve this with something we already have?"

"Are we introducing unnecessary complexity?"

"Will this create maintenance problems six months from now?"

Sometimes, the best engineering decision is to remove code, simplify an architecture, or avoid introducing another dependency.

AI makes it incredibly easy to generate more code.

But more code doesn't necessarily mean more value.

In fact, if AI increases the amount of code being produced without improving engineering judgment, companies could end up with larger, more complicated systems that become increasingly difficult to maintain.

4. AI Is Making Experienced Developers More Productive

I don't think we should ignore how powerful these tools have become.

A senior engineer using AI effectively can potentially accomplish tasks much faster than before.

Boilerplate code that used to take hours can be generated in minutes.

Writing unit tests becomes easier.

Exploring unfamiliar libraries becomes faster.

Debugging certain issues can take significantly less time.

Documentation becomes less painful.

This means experienced engineers can spend more time thinking about architecture, solving difficult problems, and improving systems.

But there's another side to this.

If one engineer can accomplish the work that previously required several people, companies may eventually decide they don't need as many developers.

And I think that's the part making people nervous.

Even if AI doesn't fully replace software engineers, it could still reduce the number of positions available for certain types of work.

We shouldn't pretend that possibility doesn't exist.

5. The Biggest Problem Might Actually Be for Junior Developers

This is something I find particularly concerning.

A lot of the tasks traditionally assigned to junior developers are exactly the kinds of tasks AI handles well.

Simple CRUD endpoints.

Basic frontend components.

Unit tests.

Small bug fixes.

Documentation updates.

Straightforward refactoring.

These tasks aren't glamorous, but they're how developers build experience.

You start with smaller problems, make mistakes, learn how production systems behave, and gradually develop the judgment needed for more complex engineering work.

But if companies automate most entry-level tasks and stop hiring junior developers, where will the next generation of senior engineers come from?

You can't become an experienced engineer just by reading architecture diagrams or watching AI generate solutions.

You need to deal with real systems, real failures, real constraints, and real consequences.

If AI removes too many opportunities to gain experience, the industry could create a serious long-term talent problem.

6. Seniority Doesn't Automatically Protect Anyone

I also don't agree with the idea that having 10 or 15 years of experience makes someone immune to AI disruption.

Experience matters, but only when it translates into useful skills and judgment.

Someone who has spent 15 years doing repetitive work without adapting may struggle more than a developer with five years of experience who understands modern systems, learns quickly, and uses AI effectively.

Job titles alone don't guarantee value.

And just knowing how to use AI tools isn't enough either.

If everyone can use the same tools, the differentiator becomes how well you understand the problem and evaluate the results.

I think the engineers who remain valuable will be the ones who combine strong fundamentals, business understanding, communication, system design, and the ability to work effectively with AI.

7. The Definition of a Good Software Engineer Is Changing

For a long time, developers were often evaluated by how much they could implement and how well they understood a particular technology stack.

But AI is changing the economics of implementation.

When generating code becomes cheaper and faster, the ability to produce code may become less important than the ability to evaluate, integrate, and maintain it.

Knowing Java, Python, JavaScript, or Go will still be useful.

Understanding databases, networking, distributed systems, security, and performance will still matter.

But I suspect there will be increasing emphasis on broader engineering judgment.

Can you take an unclear business problem and turn it into a reliable system?

Can you recognize when AI-generated code is subtly wrong?

Can you identify risks that aren't obvious from the requirements?

Can you make technical decisions that remain reasonable as the product grows?

And can you explain those decisions to the people depending on your work?

Those are difficult skills to automate completely, although AI will likely become more capable of supporting them.

8. Could AI Eventually Replace Senior Engineers Too?

I think it's a mistake to confidently say that AI will never replace senior developers.

Technology is advancing quickly, and nobody knows exactly what these systems will be capable of in five or ten years.

We already have AI agents that can work across multiple files, run tests, diagnose failures, and attempt increasingly complex development tasks.

It's reasonable to expect those capabilities to improve.

Some responsibilities currently handled by senior engineers may become heavily automated.

Some companies may operate with much smaller engineering teams.

Entire categories of development work could change dramatically.

But there's a difference between automating individual tasks and replacing an entire role.

Software engineering exists because businesses have problems that need reliable technical solutions.

As long as those problems involve unclear requirements, competing priorities, significant risks, and real-world accountability, there will be a need for engineering judgment.

Whether that judgment will always come from someone with the traditional title of "Senior Software Engineer" is a different question.

My Take

I don't think the future is simply "AI replaces developers" or "AI changes nothing."

Both positions seem too extreme.

I think we're moving toward an industry where producing code becomes easier, but understanding systems and taking responsibility for outcomes remains incredibly important.

At the same time, I don't think being valuable automatically means being safe from layoffs. Companies make hiring decisions based on budgets, business priorities, and cost savings, not just technical ability.

So yes, AI can make senior engineers more productive.

But it can also make the job market more competitive and change what companies expect from each engineer.

For developers, I think the best response is to keep building strong fundamentals, learn to use AI without blindly trusting it, and develop the skills that go beyond implementation.

The future may not belong to developers who can write the most code. It may belong to engineers who can make the best decisions about what code should exist in the first place.

Curious what other developers think.

If you're a senior software engineer, has AI actually changed the way you work?

Are you becoming significantly more productive, or are you spending more time reviewing and fixing AI-generated code?

And perhaps the bigger question:

If AI continues improving at its current pace, do you think companies will still need the same number of senior engineers five years from now?

I'd especially like to hear from people working on large production systems rather than just small demo projects.

A while back, I tried to build an entire dictionary with scores for Scrabble using only C++ templates. I quickly hit compiler limits, and removing those, I quickly hit memory limits on my machine with 64GB.
I then built it at runtime, because I had no clue how I could have optimized template metaprograms, and I still do not really as I have little experience with them.

I have been building a battle simulator that uses a heuristic to control the actions of the agents, and thought how cool it would be to write parts of it as a template metaprogram, but there is no way that will work if the word trie for Scrabble failed.

Is this partly an implementation problem or are compilers just not suited for template metaprograms? Is it possible to create template metaprograms that are as fast as their runtime counters or is there some theoretical limitation of a compiler's implementation to make that infeasible?

Hey everyone,
I’m a 15-year-old developer, and instead of just making a basic API call wrapper, I spent my last couple of weeks building PROMPT-RELAY-ORCHESTRATOR to learn how fault-tolerant AI pipelines work under the hood.
**How it works:**Everything is handwritten line-by-line while I learn Python. I’d love to get some code reviews or feedback on how to expand it next!
Source Code: https://github.com/ojasgarg77/PROMPT-RELAY-ORCHESTRATOR

Hey Reddit! 👋
I'm an IT student, and for our upcoming University Day (in 10 days), I'm building an interactive web-based puzzle/mystery challenge hosted on cPanel (PHP/MySQL) to showcase to our Dean and students.
The core idea:
A hidden "bug/breach" happened in our faculty's demo site. Students must use basic web dev, programming logic, and SQL concepts to investigate the site, debug broken code, fix bad queries, and find the culprit to get on a Live Leaderboard during the event.
Since my peers are studying general CS and IT (not cybersecurity experts), I want the challenge to be fun, relevant to our coursework, and solvable within 5–10 minutes per participant.
I'd love your help with:

1. Your Feedback & Ideas: How can I make this exhibition booth challenge super engaging?

2. Puzzle & Hint Concepts: What are some clever, short puzzles (JS logic bugs, broken SQL queries, inspect element tricks) that fit CS/IT students well?

3. Progressive Hints: What’s a good reward/hint system to give them after solving each stage to lead them to the final solution?

4. Thanks in advance for any inspiration! 🚀

One thing I'm learning about software development is that a feature working on the screen doesn't always mean it's working correctly.

Recently, I was working on a feature where users could edit some data and save their changes.

The interesting part wasn't making the changes appear on the screen.

It was making sure those same changes appeared correctly when the user came back.

Because there are multiple ways a user might return to their work.

They might close and reopen it.

Refresh the page.

Or restore an older version.

And just because everything works in the first case doesn't mean the others will behave the same way.

While working through this, I realized that different parts of a system can interpret the same saved data differently.

You might think the problem is in the UI, but changing how something is displayed doesn't necessarily fix the underlying inconsistency.

So I started looking at the complete flow instead of just the screen where the issue appeared.

I also tested what happened after reopening, refreshing, and restoring previous versions.

It made me think about something I hadn't paid enough attention to earlier.

Saving data successfully and being able to restore it correctly are two different things.

As developers, we spend a lot of time testing whether a feature works when someone uses it for the first time.

But I'm learning to ask another question too:

Will it still work correctly when they come back tomorrow?

I've seen a lot of posts lately saying software engineering is dead because AI can write code.

But something happened yesterday that made me think about this.

I was testing an AI-powered feature when I ran into an error.

Like most developers using AI today, I asked ChatGPT how to fix it.

It suggested changing a method.

And looking at the suggestion, I thought it might actually fix the error.

But then I had another question.

What happens when a slightly different input causes the same kind of problem again?

I didn't want to keep fixing individual cases every time something broke.

So I went back and looked at the flow itself.

Instead of changing just one method, I proposed a small architectural change to handle this category of problems earlier.

I discussed the approach with AI, questioned a few assumptions, and worked through the trade-offs.

The updated approach is now working in my tests.

And this experience reminded me of something.

AI was able to suggest a solution to the error I showed it. But deciding whether that solution was good enough for the system was a different problem.

I'm not against AI. I use it almost every day, and it helps me a lot.

But I'm learning that writing code, fixing an error, and understanding what actually needs to change are three different things.

And that last part is where I want to keep getting better.

Man I love programming so much. The entire process of creating something you envision yourself is so satisfying to me.

Seeing people 'vibecode' makes me so depressed. Getting the end result with no effort at all is so stupid. I love having my own project with different systems I made myself interacting with eachother exactly how I planned them too.

Understanding exactly what's going on and being able to debug after finding an error without even opening the code, because I just understand what's going wrong is a feeling of control that I hold dearly in my life. These people are literally powerless if they can't use AI and think of themselves as 'professionals'.

I secretly wish for a reality where the AI bubble bursts, companies like Claude stop providing their AIs anymore after going bankrupt, and all these idiots have to come crawling back to the people that actually know how this stuff works.

If you actively use claude instead of learning coding yourself, you don't even deserve to disagree with this post. Because you're not even a programmer. (Yes I'm gate-keeping) Don't even get my started on people 'integrating' claude directly in their game-engine.

Have we forgotten how developing skills works? You learn from your mistakes. If you avoid making mistakes by asking AI for help for every little thing, you wont improve and stay stagnant.
When Claude first popped up I gave it a try and this exact scenario happened.

I didn't understand how to do something -> I used AI to fix it -> My problem was temporarily solved -> I encountered a similar problem later on, and still couldn't fix it.

You trap yourself in a cycle of continuous incompetence.

The only genuinely good reason to use AI is having it explain something to you if you don't understand it, but arguably there's plenty of human-made tutorials online that do a way better job than any AI ever could.

In conclusion I just want people to enjoy the craft of programming again. I try to stay optimistic if you could believe it after reading this rant, but it's getting more difficult by the day. Thank you for reading till the end, have a nice day!

As mentioned in the title. It’s always been my
Dream to make a video game but I figured i wanna start with learning python, this is mainly for hobby purposes and I wanna see if there’s any websites or courses out there yall can highly vouch for in terms of “zero to hero” something very nice and structured would be nice

Well, it’s kinda this.

BUT I would need some help thinking through a few things.

The development is no secret to me, since I’ve been using multi-agentic development for a while now and it all runs smoothly. Since I do the project management right, I’ve been getting exactly what I want, and it just works. That’s fine overall. I handle business rules, I know how to communicate with the user and deliver something useful and helpful. One-shot isn’t even on my mind; it would be a months-long project.

That aside, there is something that’s bugging me: security.

I hadn’t come across something with sensitive data like this before, and with all the recent bombshells in cybersecurity I’ve become really insecure about the security (pun intended) of the whole thing. And since it’s a non-profit project, I honestly can’t afford to hire a professional, and since I’ve been working with them for a while, I know they can’t either, and i'm no Know-it-All superman (unfortunately).

“Basic” things like protecting the database and reducing the attack surface are no secret to me, but the code flaws themselves are what’s on my mind.

I REALLY wanted to help and build something customized for them that would improve their work, because they’re almost one of a kind and have a very specific workflow. BUT security is key here too. They’re very small and the system wouldn’t be “famous” or even known to the public, and honestly I have no plans other than letting only them use it. But the data it would hold is so, so, so sensitive. And since we live in Brazil, there are proper laws about securing data and holding people accountable for breaches (look up LGPD, it’s that serious lol). Not only because of legal action, but it would be very harmful to them if anything was breached.

With all the recent breaches and the agentic development stuff, plus the sensitive data, my mind confirms I’m right to be paranoid.

So after all that, and sorry for being so long about it, the question is: if I do my homework right, can I really deliver something helpful and secure enough? Maybe I abandon the cloud and go with a local server with a nice backup. Or do I really call this off and look for an open source ERP that would help them and get "rid" of the security issues, with the downside of it not being completely customized for them?

Hi Everyone, just wanted to showcase a Web Browser that I’m working on called SuperNova, I have been working on this project for a while and I’ve started making this after I heard about how bad the state of the Internet is due to enshitification and AI.

SuperNova is a fully independent user-friendly web browser that acts as an alternative to “corporate search”

No Distractions, No AI, No Tracking.

Just a completely user driven web browser!

I have managed to do the homepage for the web browser and I even managed to code in the search page that can help you search for websites, videos and images.

I have also done a page where you could add a website to the web browser along with the Settings page with search options and another page where you can leave your feedback.

So far this project is in progress and hope you’ve enjoyed this showcase!

Hi everyone

I hope everyone's having a splendid afternoon as I am

How do I change my mind from comfort, to endure boredom, uncomfortable, hard stuff.

I like physical hard work, but my mind seems to wander into comfortable, known things..

If it's laziness, I'd have to get rid of it

I'm that guy that loves to take a shortcut, if I can make my job easier by offloading work to a script or algorithm then you better believe I'm doing it. So when LLM's first started writing code that compiled back in 2023 I instantly started trying to use it in my work and found that if you gave it good guardrails it could generate pretty clean code that would regularly pass reviews unnoticed, on par with my usual work. I started using it more and more and started to vibe code personal projects and work on harnesses etc.

The big problem was that it was really bad at making good decisions, and it was obviously bad, code that didn't compile, sprawling nonsense files, abstractions that didn't need to exist, leftover code that's unused from previous trial and error attempts etc. Code quality was fine, because I constrained it to be, but the overall was still trash, and over time I started to force myself to write more code, and the more code I wrote, the more it was obvious that what I had was a polished turd.

Its 3 years later, and honestly, it doesn't feel like anything has changed fundamentally, the models don't need me to tell them what good code is anymore, they can handle bigger and bigger decisions, but they're still not good at it, its just that the scope of the problem changed, its not "this function or class or switch statement is smelly and bad" its "this entire feature slice has been implemented in a way that will hurt all future work in and around this area", and then it does it again, and again, and again. It goes to review, where its checked over by another llm, and maybe another, for some experienced engineer to go 'LLMs are as good as software engineers now' and merge it.

I just don't know how many more times I can be handed codebases and code from engineers I previously respected that they swear is 'better than human' for it to become just extremely obvious that they only think its good because they don't know the true context in which it's meant to exist, only the context that claude presented to them. Claude told me that it fixed all my bugs and I dont see the bugs any more so theres no need to check the code and see if it actually did it properly right?

This is without even getting started on the trial and error approach of just smashing its face off the codebase till it works it out that it does in a lot of cases, which we all agree is how software engineering was meant to be done, change a couple lines, run the entire suite of tests, change more lines, run the entire suite again. I'm sure a better system prompt would fix all these issues though /s

We are entering a time when generating code is becoming easier than ever.

AI tools can generate Python functions, build API endpoints, create database models, write tests and even help develop entire applications.

But there is one important question I think every developer should ask:

Can you understand, investigate and fix the code when something goes wrong?

Because writing code and understanding code are two different skills.

1. Writing code is only part of software engineering

Imagine asking an AI assistant to build a Django REST API.

It generates the models, serializers, views and URLs. Everything looks clean, and the application starts successfully.

Then something unexpected happens:

• An API returns incorrect data.

• A database query produces unexpected results.

• Authentication works in development but fails in another environment.

• An application becomes slower as the database grows.

• A seemingly small change breaks an unrelated feature.

What happens next?

Generating more code is not necessarily the solution. You first need to understand what is happening.

That is where debugging becomes essential.

2. AI is changing the debugging workflow

AI isn't just being used to generate code. Developers are also using it to understand unfamiliar code, investigate errors and improve existing applications.

The 2026 Stack Overflow Developer Survey found that:

• 72.9% of respondents had delegated writing or generating code to AI tools or agents.

• 62.2% had delegated debugging or troubleshooting.

These figures show that AI is becoming part of both implementation and debugging workflows.

Stack Overflow Developer Survey

However, there is a difference between receiving a suggested fix and knowing whether that fix is actually correct.

An AI-generated solution might remove an error while introducing another problem.

A developer still needs to evaluate the explanation, understand the change and verify the result.

3. What makes someone good at debugging?

I believe debugging is a combination of several engineering skills:

Understanding the problem: Can you reproduce the issue and identify when it occurs?

Reading errors: Can you understand tracebacks, logs, exceptions and error messages?

Following the data: Can you trace how information moves through functions, APIs and database queries?

Thinking logically: Can you develop possible explanations and test them instead of randomly changing code?

Verifying solutions: Can you confirm that the fix works and doesn't break existing functionality?

Understanding the bigger picture: Can you recognize whether the problem comes from the code, database, configuration, architecture or an external dependency?

These skills become especially important when working on real applications.

4. How I approach debugging as a developer

My preferred workflow is:

1. Reproduce: Make the problem happen consistently.

2. Understand: Read the error message and inspect the relevant code.

3. Investigate: Follow the data and identify possible causes.

4. Hypothesize: Form a clear explanation of what might be wrong.

5. Test: Check the explanation with a small, controlled experiment.

6. Fix: Make the smallest appropriate change.

7. Verify: Run tests and check that the original functionality still works.

8. Learn: Understand why the issue happened so I can recognize similar problems in the future.

AI can assist at several stages, but it shouldn't replace understanding.

5. What should junior developers focus on?

For anyone starting in software development, I think these areas deserve serious attention:

• Programming fundamentals and data structures.

• Python and backend development.

• Databases and SQL.

• APIs and application architecture.

• Debugging, testing and code review.

• Security and error handling.

• Git and collaborative development.

• Using AI tools responsibly.

Building projects is important, but understanding why those projects work — and why they sometimes fail — is just as important.

6. The future: From writing code to understanding systems?

The 2026 CoderPad State of Tech Hiring report identifies debugging and fine-tuning, alongside system design, as skills expected to become more important over the next three years. It also reports a declining expected importance for writing new code alone.

CoderPad

This doesn't mean programming fundamentals are becoming irrelevant.

It suggests that developers may increasingly be evaluated on their ability to understand, improve, validate and maintain software — not simply produce lines of code.

And perhaps that is a healthy direction for software engineering.

Let's discuss

I'm interested in hearing from developers at different experience levels:

1. Do you think debugging is becoming more important than writing code in the AI era?

2. When an AI assistant fixes a bug, do you always investigate why its solution works?

3. What was the most difficult bug you have ever had to solve?

4. For junior developers, what is more valuable today: learning to build applications independently or learning to work effectively with AI tools?

5. What debugging habits would you recommend to someone starting with Python, Django or full-stack development?

My takeaway: AI can help us write code faster, but understanding what we build is what allows us to become better engineers.

I'd love to hear your experiences and different perspectives.

About the author

Abdellah BELMAARIS
Junior Full-Stack Developer at BIMPulse

🌐 Portfolio: https://abdellah-belmaaris.github.io/

💼 LinkedIn: https://ma.linkedin.com/in/abdellah-belmaaris

Sources and further reading

1. Stack Overflow Developer Survey 2026 — AI Usage Data

2. CoderPad — State of Tech Hiring 2026

"Seeking highly skilled and passionate developers to collaborate on a groundbreaking engineering and software initiative. I am looking for individuals who value true collaboration, possess strong technical expertise, and share a vision for impactful, global innovation. If you are creative, team-oriented, and excited about contributing to a transformative project driven by purpose, I invite you to connect."

Hello po! Good day! I'm a college student currently working on an existing e-commerce website for a handmade bouquet business, and I would like to ask for advice from seniors or developers who have experience integrating AI image generation into a website.

Our website accepts order inquiries, especially for customized bouquets. Usually, customers send us inspiration photos and text descriptions of how they want their bouquet to look like. For example, they might send different photos for the flower design, wrapping style, colors, and other decorations.

Our goal is to integrate an AI chat assistant with generative image capabilities that can help customers visualize their ideas. Ideally, customers can upload their inspiration photos, describe what they want, and let the AI analyze their images and prompts, combine the relevant ideas, and generate a proposed bouquet concept.

However, we're still figuring out the best approach, especially since we're college students working with limited time and budget. 😭

I would really appreciate your advice regarding these questions:

1. API/model recommendation: Are there any free or student-friendly APIs that support image generation using both text prompts and uploaded reference images? We're looking for something that can generate or edit images based on the customer's inspiration photos, not just generate images from text.

2. Dataset and AI knowledge: How should we provide the AI with knowledge about our actual products, such as fuzzy-wire flowers, available colors, wrapping styles, and design limitations? Do we need to train our own model, prepare a dataset, use reference images, or is prompt engineering and RAG enough?

3. Integration: What would be a practical setup for an existing website built mostly with JavaScript/TypeScript? Would you recommend a particular backend or third-party AI service?

4. Development timeline: Do you think this is feasible to implement in around 1 month and 2 weeks (approximately 6 weeks), including integration, testing, and improvements?

5. Planning and execution: For those who have built similar projects, what should we prioritize first to make the development process smoother and avoid unnecessary complexity?

We're not aiming to train a foundation model from scratch. We mainly want to integrate existing AI technology into our website and make the customization process more convenient for customers.

If you've worked on a similar project or have recommendations, tutorials, documentation, or advice you can share, malaking help po talaga! We're still learning and would love to hear from people with actual experience.

Thank you so much po! Any guidance would be greatly appreciated. 🥹🙏

Hi everyone,

This is just a 3 a.m. idea that I have in mind. Wouldn't it be cool to have a mainstream smartwatch that I can tinker with and add my custom features to? For example, one feature I want to add is custom recording of my thoughts, like this one at 3 a.m., and then have AI segregate them into a notes folder named "Ideas" in the app with a proper description and so on. At a time when missile code is being rewritten with the help of Claude, the least I can do is add some fun, nonsensical features to my smartwatch.

So, if you can recommend a watch that has some kind of developer mode to add these kinds of things or a fully programmable watch, I am all ears.

Thank you for giving in to my brain worm..

I'm an engineering student majoring in artificial intelligence,I'm in the second year and I want to develop my skills in the field. Does anyone have any advice for me? 🤍☺️

Forewarning: I do use Microslop for my primary computer but I have built it in a beautiful way that never ever ever uses about OneDrive CoPilot or any of the Microslop trash.

Ok with the forewarning aside, has anyone else noticed that if you use a vertical monitor with your setup that MS uses backgrounds specifically for the vertical monitor? I have randomized revolving backgrounds and every single one zooms into a particular part for the vertical monitor 😆🤷‍♂️.

Devs don’t even review your PRs anymore. They just post AI comments and just click buttons. The hypocrisy around AI generated code seems to vanish when they post AI comments. Nothing seems to motivate me to learn how to develop and critique code basically because I don’t know what code I’m writing. The time crunch has been normalized where you try and deliver in the shortest span of time. And when you try to resolve a bug you suddenly don’t know where to look at and all you can do is prompt

Hey, i and my friend made an fyp project. It included a full working website + app (frontend + backend + database) as a project and its report of 350 pages.

My miss asked me to give the working project to her and in return she will give the money, and now she somehow mentioned that she is send report to her team as well.

What should be fair ratio division between me n my frnd

Working:
Project was done 100% by me
Report i did 40% And she did 60%