Yesterday I wrote a blog post about a question I got at a conference and I thought I try one of those fancy “AI” tools that grace my inbox every few hours. Video Tap promises to turn videos into blog posts. You give it a YouTube URL, and it writes a post for you, looking up and including relevant links and showing you an editing interface when you are done.
Sounded too good to be true, and suspicious me thought all they do is scrape the auto generated captions of YouTube and show those as paragraphs. I was positively surprised though, how thorough the tool was.
Much like ChatGPT or the Bing Chat in Microsoft Edge, it wrote a proper blog post for me, taking the information from the video. It found and included relevant links and whilst the post didn’t sound like me, it cut my writing time in half.
The editing interface reminds of Medium or WordPress, so they are treading the cowpaths here.
Context-aware screenshot tool
Not relevant to this video, but I also love that it gives you a “include screenshot” option. This one shows the video at the time stamp the generated paragraph talks about and allows you to include a screenshot of that time.
This is much more useful with content that has more meaning that just me talking. Like a slide or a code demo. Code, by the way also seems to get detected and turned into code blocks automatically.
Publish or export as Markdown or HTML
Once you are happy with the result, you can either publish the post on Video Tap, or you can export it as HTML or Markdown.
The pricing is $1 per minute of video, which is just fair and there are also bulk pricing options for YouTube channels.
Things I’d love to see
I can see myself using this a lot in the nearer future, but there are a few things I’d love to have to make it even better:
The ability to upload local videos / not publicly available hosted videos This is now a feature, hooray!
Sharing to LinkedIn / WordPress / Medium
A domain that is the name of the product. I keep forgetting “Videotapit” and “Videotap” is a domain squatting site.
As artificial intelligence (AI) continues to advance, many are concerned about its impact on the job market, particularly for junior developers. If AI can automate many of the tasks these developers currently perform, how will we have new senior developers and architects in the future? Let’s talk about how junior developers still have crucial roles to play, and why the potential automation of their tasks doesn’t necessarily mean a lack of future senior developers and architects.
During my talk at the Modern Webdevelopment meetup in Microsoft last week, I got the question about how we can have Senior Developers in the future when junior roles are being replaced by machines. Here’s what I had to say.
The Role of Junior Developers in an AI-Driven World
While AI-driven tools like GitHub Copilot and linting engines can generate code and identify issues, junior developers still have an important part to play in this evolving landscape. These developers need to learn about potential security vulnerabilities, such as cross-site scripting (XSS) and SQL injection problems, as well as performance and accessibility issues that may arise in the given code. In other words, what you write is less important than how it affects the product.
AI-driven tools may not yet be equipped to handle these specific issues, though advances are being made in this area. It seems a natural evolution to mix code generation with automatic validation and error reporting. And to feed these error reports back into the system that generated the code to avoid repetition.
Even with these tools, junior developers will still need to use their knowledge and understanding to evaluate the generated code, ensuring it is secure, performs well, and works as intended. And this comes from experiences and coaching by their peers and managers.
The role of junior developers in the age of AI doesn’t disappear; it evolves. They will need to:
Understand and identify security vulnerabilities like XSS and SQL injection problems
Diagnose potential performance issues
Evaluate AI-generated code for quality, security, and performance
Hone skills needed in this new world of machine assisted content generation. One big one that comes to mind is Prompt Engineering. Machines give better results when we ask the right questions.
Seniority in Engineering: More Than Just Writing Code
The role of senior and lead developers isn’t solely about writing code or the quantity of code written. Instead, these roles involve understanding and managing the impact of code on other team members and end-users. In other words, seniority in engineering is about how a developer effectively collaborates with their team, understands user needs, and produces reliable, secure, and efficient code solutions. And to empower your team to build processes, documentation and readable code solutions.
The more I advanced in my career, the less code I wrote. Instead, I reviewed code, evaluated tools and processes and helped junior engineers to become better coders. This is a two way street: I learned a ton by teaching and by evaluating how others approached a problem I knew to have already found the “perfect solution” for.
This understanding of impact and collaboration elevates senior developers and architects beyond those who merely produce code. While AI tools can certainly make code production more efficient, these tools can’t replace the human elements of senior engineering roles.
For example, senior developers and architects often:
Mentor and guide junior team members
Collaborate with other developers to solve complex problems
Manage and prioritise various development tasks
Provide input on architectural decisions
Understand and attend to the needs of end-users
These responsibilities require a human touch that simply cannot be replaced by AI tools.
As developers move up the career ladder from junior to senior roles to principal or architect, new challenges and opportunities arise. Some developers may prefer to avoid moving into people or product management roles, focusing instead on technical skills and contributions.
One possible solution for those who’ve reached a certain level was to invent a new role, much like how the title “Developer Evangelist” was created. These developers can then educate and inspire others while remaining deeply involved in the technical aspects of their craft.
As there is an obvious gap in the career of technical people, this may also be a good time to re-evaluate our job structures. AI can take away the level of junior developer, if that level means churning out repetitive, simple code. We could skip one level and accelerate career advancement. There is evidence that teams using AI assisted code completion are twice as effective than others, as senior engineers needed to do a lot less hand-holding. Instead, people learned by getting examples from their development environment and using it to get explanations.
In Conclusion
The fears surrounding AI’s impact on junior developers are not unfounded. However, AI tools not only transform their roles, but also create new opportunities for them to learn, grow, and eventually become future senior developers and architects. The focus should be placed on improving collaboration, understanding user needs, and contributing to a team’s efforts to create secure, efficient, and user-centered software solutions.
It’s important to remember that seniority in engineering doesn’t solely revolve around code production. Instead, it’s about the broader impact of that code on team members and users alike. As AI continues to advance and play a larger role in the world of development, humans still have an essential role to play in shaping the future of the industry.
Posted in General | Comments Off on The Future of Senior Developers in an AI-Driven World
Earlier today I spoke at the Microsoft Reactor meetup in Berlin about frontend development, LLMs, ChatGPT, GitHub Copilot and what it means to our work and careers. In this 32 minute talk and 5 minutes of Q&A, I covered a lot of ground:
Introduction
Web Development isn’t complex technology
GPT can create web products from a doodle, or can it?
I just got access to GitHub Copilot CLI and a few seconds after installing it, I am happy as a clam about it.
You can see it in action in this video or let me talk you through it here. GitHub Copilot CLI brings AI code completion to your terminal. After installing it, you get three new commands:
??: Translate natural language to arbitrary shell commands
git?: Translate natural language to Git commands
gh?: Translate natural language to GitHub CLI commands
I love using the terminal, as it gives you a lot of power and it is a lot faster than other tools like Finder or Explorer. The issue is though that it is not easy to remember the sometimes cryptic syntax of bash commands and attributes of command line tools.
This is where Copilot CLI helps. Say you want to convert all the videos in the current folder to mp4 and resize them to 640 pixels width, keeping the aspect ratio. All you need to do is write `?? convert all videos in the folder to mp4 and resize them to 640px` hit enter. You get a suggestion of code that will do that task and a detailed, human readable explanation what the code does.
You can choose to run the command immediately, revise your input in case something feels off or cancel and go back to the terminal.
Another prompt I tried was `?? find all files bigger than 500mb and copy them to a folder called huge` and the result was immediate.
I like that it doesn’t only give you the result, but also explains what the code does. This often is missing from answers on StackOverflow and other forums.
It will be interesting to see where this goes. The Terminal is a mighty tool and you can do a lot of damage if you are not aware of the consequences of your commands. It would be interesting to see Copilot also give you some safety instructions with every command it offers.
Posted in General | Comments Off on GitHub Copilot for the Command Line is amazing!
I was just about to write a blog post on my current experiences in trying to find a new job. I wanted to write about the frustrations and how it feels ridiculous that developers and recruiters aren’t best friends. And then I remembered that Microsoft Edge now comes with a HUGE Bing icon that promised ChatGPT functionality right in the browser.
So I pressed the b, went to the “Compose” tab, entered “Developers and Recruiters should be friends”, selected “professional”, “blog post” and “medium length” and this is what came out of it:
Developers and Recruiters should be friends
If you are a developer, you might have a love-hate relationship with recruiters. On one hand, they can help you find your dream job and negotiate a good salary. On the other hand, they can spam you with irrelevant offers and pressure you to accept a position that is not a good fit for you.
But what if I told you that developers and recruiters can actually be friends? That they can work together to achieve their mutual goals and benefit from each other’s expertise and network? That they can respect each other’s time and preferences and communicate effectively?
In this blog post, I will share some tips on how developers and recruiters can build a friendly and productive relationship that will help both parties succeed in their careers.
One of the most important aspects of any relationship is honesty and transparency. Developers and recruiters should be honest and transparent about their expectations, skills, availability, interests, and feedback. This will help avoid misunderstandings, frustration, and wasted time.
For example, if you are a developer, you should be honest and transparent about:
Your current employment status and notice period
Your salary expectations and benefits requirements
Your preferred location, work environment, and company culture
Your technical skills, experience level, and portfolio
Your career goals and learning objectives
Your feedback on the job opportunities and interviews
Similarly, if you are a recruiter, you should be honest and transparent about:
The details of the job opportunity and the hiring process
The salary range and benefits package
The company’s mission, vision, values, and culture
The expectations and responsibilities of the role
The feedback from the hiring manager and the next steps
Another key aspect of any relationship is respect and professionalism. Developers and recruiters should treat each other with respect and professionalism at all times. This means being courteous, polite, responsive, punctual, and constructive.
For example, if you are a developer, you should:
Respond to the recruiter’s messages in a timely manner
Inform the recruiter if you are no longer interested in the job opportunity or if you have accepted another offer
Show up for the interviews on time and prepared
Thank the recruiter for their time and effort
Provide constructive feedback on the job opportunity and the hiring process
Similarly, if you are a recruiter, you should:
Respect the developer’s time and availability
Tailor your messages to the developer’s profile and preferences
Provide clear and accurate information on the job opportunity and the hiring process
Follow up with the developer after each interview stage
Provide constructive feedback on the developer’s performance and potential
The final aspect of any relationship is helpfulness and supportiveness. Developers and recruiters should help and support each other in achieving their goals. This means sharing useful resources, advice, tips, referrals, recommendations, and encouragement.
For example, if you are a developer, you can:
Ask the recruiter for tips on how to prepare for the interviews
Share your portfolio or GitHub profile with the recruiter
Refer other developers who might be interested in the job opportunity
Recommend the recruiter to your network or leave a positive review on their profile
Congratulate the recruiter if you get hired or wish them good luck if you don’t
Similarly, if you are a recruiter, you can:
Provide the developer with relevant information on the company and the role
Share your insights on the market trends and salary expectations
Introduce the developer to other hiring managers or recruiters who might have suitable opportunities
Recommend the developer to your network or leave a positive review on their profile
Congratulate the developer if they get hired or wish them good luck if they don’t
Conclusion
Developers and recruiters should be friends. They should be honest and transparent, respectful and professional, helpful and supportive. By following these tips, developers and recruiters can build a friendly and productive relationship that will benefit both parties in their careers.
Isn’t this bonkers? It is well written, it gives really good advice, it even feels like it is written by someone with lots of experience and empathy for both sides of the argument. And it is well structured in headings and lists to be accessible (albeit probably not here as I put a blockquote around it) and SEO optimised. Sure, there is some repetition that betrays its origin, but with a bit of editing, you could have an article that looks good, feels great and is generic enough not to annoy anyone.
And that is the issue, isn’t it? When I started blogging in 2005, my blog was a scratchpad. I learned something, and I wanted to write it down so that I don’t forget it. It was messy, it was at times plain wrong (but at the time OK) and I didn’t give a damn about its SEO. I always made sure I do the most I can to be accessible, but all my Google juice came by accident and word of mouth.
What does that mean for people who want to start writing and having their place on the web now? Personally, I think if you try to optimise for search engines or social share-ability you’re in for a lot of frustration. Or you can do what I did and let the machine do the work. Black hat SEO (and those with a dirty grey hat) have been content farming for years and generating nonsense articles full of links and keywords. Some of that was automated, but now the floodgates are open and anyone could create a clever sounding blog or even online magazine with a few clicks.
Instead, I think this is a great time to be, well, human. To write what you want to. To admit to your errors. To show what excites you and why and not write a “7 ways to use XYZ to boost your ABC”. I’ve been around this for a long time, and the people I do remember, still follow and keep telling others about are those who allow themselves to be a person, and not a “content creator”.
Shine on, you fabulous whateverthehellyouare !
Posted in General | Comments Off on This is the time to be unpredictable and human
